Unity 촬영: 프리팹과 레이캐스트 및 게임 개발의 기초

Unity에서 촬영은 원하는 총알의 동작과 정밀도에 따라 프리팹 또는 레이캐스트를 사용하여 수행할 수 있습니다.

### Unity 촬영 튜토리얼: 프리팹과 레이캐스트 비교
* 🔫 "Unity에서 촬영할 때는 두 가지 방법이 있습니다. **프리팹 또는 레이캐스트**를 사용할 수 있으며, 어떤 방법을 선택하느냐는 달성하고자 하는 목표에 따라 달라집니다."
* 🚀 "플레이어가 공중을 이동하며 목표물에 도달하는 데 시간이 걸리는 **총알을 쏘게** 하려면 **프리팹을 사용**하는 것이 좋습니다."
* 🎯 레이캐스팅을 사용하면 총알이 공중을 통과하는 대신 **보이지 않는 선을 즉시 발사**하여 해당 방향의 대상에 명중했는지 여부를 확인할 수 있습니다.
* 🔄 "두 가지 방법은 사실 매우 유사합니다. **촬영을 트리거할 때도 같은 코드**를 사용하고 **피해를 입힐 때도 같은 코드**를 사용합니다."
* 🎮 "프리팹 촬영의 경우 **총알 프리팹을 생성**하고 촬영할 때마다 사본을 생성한 다음 **힘을 가하여 움직이게 합니다**."
* "광선 캐스팅의 경우 **특정 방향의 한 지점에서 광선을 내보내고, 광선이 무언가에 부딪히면 피해를 입히는** 방식입니다."
* 🎨 "임팩트 효과 및 라인 렌더러와 같은 **시각 효과를 추가**하여 촬영 위치에 대한 피드백을 제공할 수도 있습니다."
* 💥 "Unity에서 **프리팹과 레이캐스트 슈팅 방식**을 모두 이해하고 구현하면 게임에 매력적인 인터랙티브 슈팅 메커니즘을 만들 수 있습니다."

when it comes to shooting in Unity, there's really two ways to go about it. You can do it using prefabs or raycasts, and which method you choose depends on what you want to achieve. If you want your player to shoot bullets that travel through the air and takes time to reach the target, using prefabs is probably the way to go. With this method, we basically create a bullet prefab and then spawn in a copy of it every time we want to shoot. We can then apply forces to the bullet in order to make it move and check to see if it collides with anything, in which case we can make it explode and apply damage. Another way to make your player shoot is by using raycasts. Instead of your bullets traveling through the air, we instantly shoot out an invisible line that checks whether or not we hit anything in that direction. The result is a much quicker and precise shot, like we see in modern first-person shooters like Call of Duty or Counter-Strike. The two methods are actually very similar. We use the same code for triggering the

shooting and the same code for applying damage. So, with that explanation, let's get right to it. But first, let's not jump the gun on this one. This video is sponsored by Dennis Ventura. Dennis is an awesome game dev tutor who's just launched a new course on Udemy: the complete C-sharp master class. This course will make you completely comfortable writing code in C-sharp and using it for programming your own games in Unity. It will give you knowledge on many different aspects of C-sharp and teach topics like databases, LINQ, and WPF, and much more. At the end of the class, you will even have made three games on your own. If this sounds like something you're interested in, simply click the link in the description to get started and get a discount. All right, let's start shooting. No matter what method that we'd like to use, there are a few things that we need to set up. One of these is that we need to create a fire point, and a fire point is really as simple as it sounds. It's

just the point from where we want to fire our bullets. So if we go ahead and select our player here and right-click on him, we can create an empty object. We can then take this object and move it to the place that we would like to fire from. So in my case, I'm going to move it just outside the barrel here. We then rename this object to fire point. And now if we take our game view and dock it to the side here and play, we can see that as we move the fire point, indeed follows our player. And if we move to the other direction, it also flips. However, we can also see that the direction of the fire point isn't actually changing. And this is a problem because if we try to shoot using this, we would fire to the right when we are facing right, and we would also fire to the right when we are facing left. And so we would hit ourselves, and that wouldn't be too pretty. And the reason for this is actually a mistake that I made in the character controller. If

you're using another movement script. This might not happen to you, but for those of you who followed our guide on 2D movement, we need to select our player and find our CharacterController2D. And if we open this up, it's a really big and complicated script. But at the very bottom, we have some code for flipping the character. And in here, I thought it was a good idea to flip the player by inverting the scale on the X. But instead, it would be much better if we simply rotate the player. So let's replace this entire piece of code here with `transform.Rotate` and then we want to rotate by 0 on the X, 180 on the Y, and 0 on the Z. And that should do the trick. So now if we go and play, select our fire point, we can see that as we move to the different sides, the direction of our fire point is also flipped. Awesome. So now we're ready to start creating our weapon. And to do this, we'll select our player. I'm just gonna

collapse the script again. Let's hit add component and let's type in weapon. We want to create a new script. Let's hit create an ad. Let's double click it to open it up in Visual Studio. And for now, this script is actually going to be really simple. We can go in and remove the start method. And instead, we want to create a reference to our fire point so that we can use it later. So in here, we'll write public transform and let's call this variable fire point. Then if we save that, we can go into Unity and we can also simply take our fire point and drag it into this empty slot. And at this point, we're ready to start shooting. And of course, the first thing that we need to figure out is when to shoot. So inside of our update method, let's create an if statement. And what we want to check for here is some player input. So we go input.getButtonDown. So this is triggered whenever we push a button. And the button that we want to look for is fire one. We'll then close the

parentheses, and open and close some curly brackets. And now, every time we press the fire button, we want to go ahead and shoot. And this is not a function that Unity has, this is something that we need to create ourselves. So let's go down here under the update method. Let's write void shoot, open and close some parentheses, and some curly brackets. So now, every time we press the fire button, it's going to call the shoot method, and everything inside of these two curly brackets is going to be executed. So this is where we'll put all of our shooting logic. If you want to change what button to press in order to fire, you can always go into Unity, go edit project settings, input, and find the fire one at the top here. And we see currently the button to press is Mouse zero, which is left mouse, but you can change this to anything that you'd like. I'm gonna change it to space. And at this point, what we need to do next is going to depend on what method you choose. Let's start by focusing on prefab.

shooting. So here, we first want to go ahead and create a bullet. Let's save the script and head into Unity. And in here, we want to first create a sprite. So that's right-click in the hierarchy, go to the object, and select sprite. And the sprite that you want to use here is completely up to you. I'm just gonna go under sprite here and search for shot and have this pretty cool shot - sprite. I think that looks pretty good. And then gonna take this object and rename it to bullet. And there are a few things that we need to add to this object. The first one is a Rigidbody 2D. This object will apply physics to a bullet and allow it to travel through air. You can play around with these settings to get your bullet to behave in different ways. Now, I don't want any gravity on my bullet. I just wanted to travel in a straight path. So I'm gonna set gravity scale to zero. I also don't want it to be able to rotate in any way. So I'm gonna go into

constraints and freeze the rotation. And finally, I really recommend setting collision detection from discrete to continuous. This is gonna help the bullet detect all the objects if it's traveling really quickly. Now the next component we need is a Circle Collider. So let's hit add component and search for Circle Collider 2D. I'm just gonna open this up and check that the collider is pretty close to our sprite. I think that looks pretty good. I'm also going to mark this Collider as a trigger. And this is because I don't want my bullet to bounce around the environment. I just wanted to notice when it hit something and then explode. But you can definitely leave it as a normal Collider if you wanted to keep bouncing around. So now we can take this bullet and turn it into a prefab. Let's drag it from the arc into our assets folder and we then delete it from our scene. So now we have this bullet prefab that we can make copies from. Let's go into our weapon script and let's create a reference to this object. So we'll create a public

game object. Let's name it bullet prefab. And then inside of our shoot method, we simply want to spawn a bullet into our world. Remember, whenever we want to spawn an object, we use instantiate. We then feed it the object that we want to spawn. So in our case, that's our bullet prefab. Then we need to choose where we want to spawn it. We want to spawn it at fire point dot position. And then with what rotation? And we want to use fire point rotation. So we close that off with HTML colon. And now if we save this and go into Unity and select our player, we can see at the bottom here we have the bullet prefab slot. Here we can take a bullet prefab and drag it in there. And now if we play and try to shoot, we can see that we are indeed instantiating bullets into our world. Of course, these bullets currently aren't going anywhere, but they're definitely there. Next, we can go to our bullet and create a new script on this bullet. Let's just call the script bullet.

let's take crane add and open it up in visual studio, and what we want to do in here is actually really simple. In fact, we don't even need an update method. All we need to do is that right when the bullet spawns. So inside of the start method, we want to tell the pilot to fly forward. To do this, we need a speed. So we'll go up here and create a public float speed and set it to something like 20. We also need a reference to a rigidbody since it's our rigidbody that controls our bullet. So create a public rigidbody 2d. Let's just call it RB. Then inside of our start method, we can tell a rigidbody to move. So RP dot velocity. The velocity is our current speed of the rigidbody on the three axis, and we want to set this equal to the forward direction. So transform dot. And we don't actually want to use forward here because that moves on the set axis, and we're making a 2-d game, so we don't use

this set axis at all is that we want to use right, and we then multiply this with our speed. So we're basically just saying, Hey, Rigidbody, please move right according to our speed. And if we save this, we can see that we now have a speed variable that we can adjust, as well as a slot for our Rigidbody that we can simply drag in. And now if we play and try and shoot, we can see that our bullet indeed does move forward. Awesome! Of course, the next step is to have our bullet actually register when it hits something. And if we hit an enemy, we want to apply some damage. To do this, we go into our bullet script. We use a really handy function in Unity called OnTriggerEnter. So we'll write void OnTriggerEnter2D. We'll open closed some parentheses and some curly brackets. And of course, as the name suggests, this function will be called whenever something enters our trigger. In our case, whenever our bullet hits something. And when that happens, we want to do some different things. We could, for example

destroy. I'll pull it, and maybe before we do that, we can print out the name of the object that we hit. But in order to get some information about the object, we need to go up here and add an argument. We want to add a Collider2D, and we'll call this something like hitInfo because it will store information about what we hit. Then inside of a function, we can go debug.log in order to print out a message, and we want to print out hitInfo.name, so the name of the object that we hit. If we save this and go to Unity and play the game, we then shoot our enemy, and you can see as soon as our bullet hits our enemy, it prints out enemy. Pretty cool. And of course, if we shoot in the opposite direction, nothing happens because we didn't hit anything. Awesome. Of course, we don't just want to print out enemy; we actually want to damage our enemy. And currently on my enemy, I have this BoxCollider as well as an enemy script, and this is a fairly

simple script that you can easily just copy from the screen. Here what we're doing is just giving our enemies some health, and then we are adding a function that allows it to take damage. Of course, we want to specify how much damage, so it takes in an argument with exactly that. We then subtract from our health the amount of damage specified, and if our health goes below zero, well, then we want to die. So that takes us down here, and this simply creates a death effect as well as destroys the enemy. Fairly simple stuff. The only thing to take note of here is that in order to trigger this take which function, I've marked it as public so that we can now go inside of our bullet script and call it from in here. So what we want to do here is go hit info dot get component of type enemy. So we try and find an enemy component on the object that we hit. Of course, we aren't always going to be hitting an enemy, so we're not sure that there's gonna be a component there, and because

of this, we want to store this in a variable. The variable is going to be of type enemy, and let's just call it enemy. Also, right after here, we want to check if enemy is not equal to null. So, if we actually found an enemy component on the object that we hit, well, in this case, we can go enemy.takeDamage and call the function that I just showed you. And here, we can input any number. We could put 30 damage, 40 damage, whatever you'd like. Or we could go to the top and create a variable for this. So, we'll create a public integer, let's call it damage, and set it equal to 40 by default. And then we can simply input our damage variable down here. And now we should see that whenever we play and shoot our enemy, the health of our enemy gets reduced. And once we reach zero, our enemy explodes. Super cool. And if you want to make this look even cooler, we can create a tiny impact effect whenever a bullet collides with something. In fact, I've gone ahead and prepared a prefab.

here called impact effect, and this is just a sprite renderer with some animation. Let me just add it to the scene here and play it back so that you can see. Very simple. I've also gone under the animation and made sure to disable looping. So, inside of our bullet script, we could create a public game object impact effect, and then whenever we hit something, we could simply create an impact effect. So, instantiate impact effect, the place where we want to create it is transformed our position and transform rotation. Let's save that. Going to unity, select our bullet, and now under our bullet script, we now have an empty impact effect. Let's drag our impact effect prefab under there, hit play, and now every time we hit our enemy, we can see a tiny impact effect gets created. And the same thing if we hit anything else like a platform. Pretty cool. And also, we can delete this again. So, that is how you can do prefab-based shooting. Now, let's rewind a bit and see what we can do with raycasting. So, this time, we have no bullet.

prefabs flying around. Instead, we do everything inside of our weapon script, which currently looks like this. And of course, the first step to ray casting is sending out a ray. To do that, we use Physics2D.Raycast. This will send out a ray from a point and then in a certain direction. The point that we want to fire from is, of course, firePoint.position, and the direction is firePoint.right. This will go ahead and send out a ray. It's really that simple to do. Of course, we need to store some information about what we hit, if we hit anything at all. To do that, we'll go ahead and create a variable here called RaycastHit2D, and we'll call it something like hitInfo because it stores information about what we hit. Then right underneath here, we can say that if hitInfo, and this is just a very simple way of writing if we hit something, well then we could, for example, print out the name of what we hit. So, we could go Debug.Log(hitInfo).

transform dot name now. If we save this and go into Unity and hit play and try to shoot in the direction of our enemy, we can see that it prints enemy. Whereas if we shoot in the opposite direction, nothing happens. So indeed, this is working. But it's currently completely invisible and it's not even damaging our enemy in any way. Luckily, applying damage to our enemy in this way is just as simple as with raycast shooting. In fact, the code is pretty much identical. First, we take the hidden foe object, we go under its transform, and try to get a component on the object called enemy. Of course, we're not always going to be hitting an enemy, so we want to store the result of this in an enemy variable. I will just call it enemy as well. Then we'll check if we actually hit an enemy. So if enemy is not equal to null, well then we can call enemy dot take damage and input some damaged amount. And the last time we put this code on our bullet script, but now we simply have it here in the same script.

so we'll also put our damage variable here. Let's go public int damage and set it to 40 by default. And let's then simply pass that in down here. And now if we play the game with our enemy selected and try and shoot, we can see that the health does indeed go down. And when it reaches zero, our enemy dies. But again, this is totally in this. We want some kind of graphic showing what's happening. So we could add an impact effect just like we did with Ray cash shooting. And it's really just a symbol. We create a public game object, call it impact effect. And then if we hit something, we instantiate the impact effect at the point that we hit. So hit info dot point. And the rotation here doesn't matter. So we'll simply use catonian dud identity, which is basically just a very fancy way of saying no rotation. And so we could select our player and drag our impact effect into the slot. And now we still can't see any kind of bullet, but we are able to see the impact effect itself so.

the last thing that we need to add is some visual feedback showing where we shot. And for this, I really like to use a line. So we'll right-click here and go and do effects and create a line. And by default, this is not going to be visible. And that's because of a couple of things. First of all, we want to go to the order in layer here and bump that up to make sure it's drawn on top of everything else. And also, if we go under positions, we can see the two positions that currently make up our line. It goes from 0 0 0 to 0 0 1. And so it's only changing in the z-axis, which we can't see from a 2D perspective. So instead, let's change that to 0 and try and move it on the X. Of course, we can also adjust the appearance of a line. If we go under color, we get this gradient editor where we can adjust the color over the length of our line. So if we want it to tend it

in any way, we do that there. I'm just gonna leave it white. We can also add some int gap vertices if you don't like it being completely square, just to round it off a bit. And finally, we can adjust it by simply dragging on this line here. So I think something like this looks pretty nice. I want it to be fairly subtle. We can also go to the top here and tell it to use world space so that we can't really move it anywhere unless we change the positions in our array. Now let's take this line and drag it under the player, and let's try to control it through our script. First, we need a reference to it, so we'll create a public line renderer. Let's just call it line renderer. Then whenever we shoot and hit something, we want a line to go from the point where we shot to the point where we hit. So we can go line renderer dot set position, and we want to set the first position, so index 0 - fire point dot position. We'll then set our end positions.

line renderer that said position one to hit info dot point and that should work just fine. However, we don't always hit something, and in the case that we don't hit anything, we just want our line to continue infinitely in space, or at least give the appearance that it does. To do that, we'll use the same code, so we'll copy it and then create an else to these if statements. Or in the case that we don't hit something, we can use these same two lines. We want to set the start position to our fire point. However, we don't have an end position, so instead we'll use fire point dot position and then add on to that fire point dot write x say a hundred. So, for those of you who aren't too familiar with vector math, basically what we're doing here is we're taking the start position and we're just shifting it 100 units forward. So now if we save that and select our player and drag in the line, we can see that whenever we fire, our line will be drawn.

between us and the point that we hit. Pretty cool, of course. Currently, our line is always visible. To change this, we will select a line and disable the line renderer. And then, inside of our script, whenever we shoot, we want to enable it. So we'll go line renderer dot enabled equals true. We then want to wait for a very tiny amount of time. In fact, we only want to wait one frame. So we'll wait one frame. I'll show you how to do this in a sec. And then we want to disable it again. So line renderer dot enabled equals false. And the way that we wait one frame in Unity is actually fairly simple. However, we can't do it inside of a normal function. Instead, we need to turn this into what we call a coroutine. And coroutines are fairly simple to use, but their syntax is pretty scary. So just write after me for now. Instead of void here, we'll write IEnumerator. So now we've turned it into a routine. We can't just call it the normal way. Instead, we need to add StartCoroutine.

because we want to tell unity that it's a coroutine and we want to start it. And then inside of the parentheses we'll put our function. And so now we can go down here and we can wait a frame. And to do that we write yield return zero. Again, how coroutines work is the subject for another video. For now, just right after me. And of course, have a link to where you can learn more in the description. And now we can simply save and head into unity and maximize our game. And everything should be working. So let's try and fire. And indeed, everything is working. Awesome, that's pretty much it for this video. If you enjoyed it, make sure to subscribe and ring that notification bell so you don't miss the next one. Also make sure to follow our new Instagram for updates and behind the scenes stuff. Also don't forget to check out the complete C# master class using the link in the description. On that, thanks for watching and I will see you in the next video. Thanks of the awesome patreon supporters who donated.

in August, and a special thanks to Alexander, player simmer io cheater, 3d infinity PPR - VR systems, Sybok, mommy Thirteen's, kirk personify, thanks so long, Lilith Clinton, Vince, Kuya, Ronan, Tynan Sullivan, for presea Timah, for the park, James P Bruins, cat now, Kiyosaki, Gregory Pierce, Larry, tweet cure, Swedish key, James Rogers, propfan, Robert boon, Anthony patent, and Erasmus. You guys rock.

2D Shooting in Unity (Tutorial)

Learn how to make video games!

Top-quality game development tutorials on everything from Unity, Godot and programming to game design. If you want to become a developer this channel will help guide you through it!

Join us on Discord: https://discord.gg/brackeys

► All content by Brackeys is 100% free. We believe that education should be available for everyone.


Brackeys

Unity에서 촬영하기: 프리팹과 레이캐스트

Unity에서 총격은 공중을 통과하는 총알을 위한 프리팹을 사용하거나 레이캐스트를 사용하여 더 빠르고 정밀한 총격을 할 수 있습니다.

두 방법 모두 유사한 코드를 사용하여 사격을 트리거하고 대미지를 적용합니다.

두 방법 모두 총알이 정확한 위치와 방향에서 발사될 수 있도록 발사 지점을 설정해야 합니다.

게임 개발 튜터인 데니스 벤츄라가 Udemy에서 C-sharp와 Unity 게임 프로그래밍을 마스터할 수 있는 새로운 강좌를 개설했으며, 제공된 링크를 통해 할인 혜택을 제공합니다.

플레이어 캐릭터 컨트롤러 업데이트 및 무기 추가하기

이 스크립트는 더 나은 뒤집기 효과를 위해 transform.

Rotate 메서드를 사용하여 플레이어를 회전하도록 캐릭터 컨트롤러를 업데이트하는 방법을 안내합니다.

그런 다음 간단한 무기 스크립트를 생성하고 Unity에서 플레이어의 발사 지점을 설정하는 방법을 보여줍니다.

또한 튜토리얼에서는 사격을 위한 플레이어 입력을 감지하는 방법을 설명하고 사용자가 필요에 따라 발사 버튼을 커스터마이징하도록 권장합니다.

Unity에서 총알을 만들려면 먼저 오브젝트에 스프라이트를 추가한 다음 리지드바디 2D 컴포넌트를 추가하여 총알이 이동하는 데 필요한 피직스를 적용해야 합니다.

직선 총알 경로의 경우 중력 스케일을 0으로 설정하고 회전을 고정하는 것이 좋습니다.

원형 충돌기 2D 컴포넌트를 추가하고 위치를 조정한 다음 트리거로 표시하면 총알이 물체를 감지하고 충돌 시 폭발할 수 있습니다.

마지막으로 총알 오브젝트를 나중에 사용할 수 있도록 프리팹으로 전환하고 이 프리팹에 대한 참조를 무기 스크립트에 생성하여 게임 월드에 총알을 스폰해야 합니다.

C#을 사용하여 Unity에서 포워드 무빙 불릿 만들기

이 코드는 2D 게임에서 총알의 속도를 설정하고 Rigidbody2D를 사용하여 총알을 앞으로 이동시킵니다.

총알이 무언가에 맞았을 때를 등록하기 위해 OnTriggerEnter2D 함수가 사용되며, 현재 구현에서는 총알이 맞은 물체의 이름을 출력하고 총알을 파괴합니다.

다음 단계는 총알에 맞았을 때 적에게 피해를 주는 로직을 구현하는 것입니다.

유니티에서 적의 체력과 피해 구현

적에게는 생명력 수치와 피해를 입는 기능이 주어지며, 받는 피해량을 지정할 수 있습니다.

적에게 피격당하면 'takeDamage' 함수가 호출되어 적의 체력이 감소하고 체력이 0 이하가 되면 사망 효과가 발동됩니다.

총알 스크립트의 "인스턴스화" 기능을 사용하여 적을 맞았을 때 시각적 효과를 표시하는 충격 효과 프리팹이 생성되어 충격 효과를 생성합니다.

Unity에서 2D 무기 스크립트 제작하기

Raycast를 사용하여 점과 방향에서 광선을 내보냅니다.

적중 대상에 대한 정보를 저장하고 적 물체에 피해를 입힙니다.

스크립트에는 타격 지점에 충격 효과를 추가하는 기능도 포함되어 있어 사격 액션에 대한 시각적 단서를 제공합니다.

Unity 게임에서 촬영을 위한 라인 시각화 조정하기

Unity 게임에서 사격의 선 시각화는 위치와 모양을 조정하여 개선할 수 있을 뿐만 아니라 아무것도 맞지 않을 때 무한히 이어지도록 만들 수도 있습니다.

라인 렌더러의 시작과 끝 위치를 설정하면 목표물에 맞았을 때 샷의 경로를 정확하게 표시하고, 아무것도 맞히지 않았을 때는 무한대로 연장할 수 있습니다.

월드 스페이스를 사용하면 선의 움직임을 더 잘 제어할 수 있으며, 그라데이션 편집기를 통해 선의 모양을 조정하고 간격 정점을 추가하여 보다 둥글게 보이도록 할 수 있습니다.

Unity 튜토리얼: 코루틴으로 라인 렌더러 제어하기

이 튜토리얼에서는 Unity에서 촬영할 때만 라인 렌더러를 표시하도록 설정하는 방법을 설명합니다.

이를 위해 기본적으로 라인 렌더러를 비활성화했다가 촬영할 때 활성화한 다음 코루틴을 사용하여 한 프레임을 기다립니다.

코루틴을 사용하면 프로그램의 정상적인 흐름을 방해하지 않고 한 프레임을 기다릴 수 있습니다.

이 튜토리얼은 촬영 시 라인 렌더러의 기능을 보여주는 Unity 데모로 마무리합니다.