Unity Shooting: Prefabs vs. Raycasts and Game Development Basics

The shooting in Unity can be done using prefabs or raycasts, depending on the desired bullet behavior and precision.

### Unity Shooting Tutorial: Prefabs vs. Raycasts
* 🔫 "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 take time to reach the target**, using prefabs is probably the way to go."
* 🎯 "With raycasting, instead of your bullets traveling through the air, you instantly shoot out an invisible line that **checks whether or not you hit anything in that direction**."
* 🔄 "The two methods are actually very similar. We use the **same code for triggering the shooting** and the **same code for applying damage**."
* 🎮 "For prefab shooting, you create a **bullet prefab**, spawn a copy of it every time you want to shoot, and **apply forces to make it move**."
* "For raycasting, you send out a **ray from a point in a certain direction**, and if it hits something, you **apply damage**."
* 🎨 "You can also add visual effects like **impact effects** and a **line renderer** to provide feedback on where you're shooting."
* 💥 "By understanding and implementing both **prefab and raycast shooting methods** in Unity, you can create **engaging and interactive shooting mechanics** for your games."

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

Shooting in Unity can be done using prefabs for bullets that travel through the air, or by using raycasts for a quicker and more precise shot.

Both methods involve triggering the shooting and applying damage with similar code.

A fire point needs to be set up for either method, ensuring that the bullets are fired from the correct location and direction.

Dennis Ventura, a game development tutor, has launched a new course on Udemy for mastering C-sharp and Unity game programming, offering a discount through the provided link.

Updating the Player Character Controller and Adding a Weapon

The script guides the user through updating the character controller to rotate the player using the transform.

Rotate method for a better flipping effect.

Then, it demonstrates how to create a simple weapon script and set up the player's fire point in Unity.

The tutorial also explains how to detect player input for shooting and encourages the user to customize the fire button as needed.

To create a bullet in Unity, first, a sprite needs to be added to the object and then a Rigidbody 2D component to apply physics for the bullet to travel.

Setting the gravity scale to zero and freezing the rotation is recommended for a straight bullet path.

Adding a Circle Collider 2D component, adjusting its position, and marking it as a trigger allows the bullet to detect objects and explode upon impact.

Finally, the bullet object should be turned into a prefab for future use, and a reference to this prefab needs to be created in the weapon script to spawn the bullet into the game world.

Creating a Forward Moving Bullet in Unity Using C#

The code sets the speed of the bullet and uses the Rigidbody2D to move it forward in a 2D game.

The OnTriggerEnter2D function is utilized to register when the bullet hits something, with the current implementation printing the name of the object it hits and destroying the bullet.

The next step would be to implement the logic for damaging the enemy when hit by the bullet.

Implementing Enemy Health and Damage in Unity

Enemies are given a health value and a function to take damage, with the ability to specify the amount of damage taken.

The "takeDamage" function is called when the enemy is hit, reducing their health and triggering a death effect when the health goes below zero.

An impact effect prefab is created to show a visual effect when the enemy is hit, using the "instantiate" function in the bullet script to create the impact effect.

Raycast to send out a ray from a point and direction.

It stores information about the hit target and applies damage to the enemy object.

The script also includes the functionality to add an impact effect at the hit point, providing a visual cue for the shooting action.

Adjusting the Line Visualization for Shooting in a Unity Game

The line visualization for the shooting in a Unity game can be improved by adjusting its position and appearance, as well as making it continue infinitely when not hitting anything.

By setting the start and end positions of the line renderer, it can accurately show the path of the shot when hitting a target, and extend indefinitely when not hitting anything.

Using world space allows for better control of the line's movement, and adjusting its appearance can be done through the gradient editor and adding in gap vertices for a more rounded look.

Unity Tutorial: Controlling Line Renderer with Coroutines

The tutorial explains how to make a line renderer visible only when shooting in Unity.

To achieve this, the line renderer is disabled by default and then enabled when shooting, followed by a one-frame wait using a coroutine.

By using coroutines, the function is able to wait for a frame without disrupting the normal flow of the program.

The tutorial concludes with a demonstration in Unity to show the functionality of the line renderer when shooting.