Message from @Broo TulsiGang 2024 🇬🇧 🇺🇸

```There are several ways to handle a gun’s bullets in video games. In this tutorial series, we will be exploring two of the more common ways: Objects, and raycasts.

One of the two ways is using a bullet object. This will be an object that travels through the world and handles its own collision code. This method we create/spawn a bullet object in the direction our gun is facing, and then it sends itself forward.

There are several advantages to this method. The first being we do not have to store the bullets in our player. We can simply create the bullet and then move on, and the bullet itself with handle checking for collisions, sending the proper signal(s) to the object it collides with, and destroying itself.

Another advantage is we can have more complex bullet movement. If we want to make the bullet fall ever so slightly as time goes on, we can make the bullet controlling script slowly push the bullet towards the ground. Using a object also makes the bullet take time to reach its target, it doesn’t instantly hit whatever its pointed at. This feels more realistic because nothing in real life moves instantly from one point to another.

One of the huge disadvantages performance. While having each bullet calculate their own paths and handle their own collision allows for a lot of flexibility, it comes at the cost of performance. With this method we are calculating every bullet’s movement every step, and while this may not be a problem for a few dozen bullets, it can become a huge problem when you potentially have several hundred bullets.

Despite the performance hit, many first person shooters include some form of object bullets. Rocket launchers are a prime example because in many first person shooters, rockets do not just instantly explode at their target position. You can also find bullets as object many times with grenades because they generally bounce around the world before exploding.```

Ondsinet

2019-02-01 14:26:27 UTC

```While I cannot say for sure this is the case, these games probably use bullet objects in some form or another: (These are entirely from my observations. They may be entirely wrong. I have never worked on any of the following games)

Halo (Rocket launchers, fragment grenades, sniper rifles, brute shot, and more)

Destiny (Rocket launchers, grenades, fusion rifles, sniper rifles, super moves, and more)

Call of Duty (Rocket launchers, grenades, ballistic knives, crossbows, and more)

Battlefield (Rocket launchers, grenades, claymores, mortars, and more)

Another disadvantage with bullet objects is networking. Bullet objects have to sync the positions (at least) with however many clients are connected to the server.

While we are not implementing any form of networking (as that would be it’s own entire tutorial series), it is a consideration to keep in mind when creating your first person shooter, especially if you plan on adding some form of networking in the future.

```

Ondsinet

2019-02-01 14:28:45 UTC

```The other way of handling bullet collisions we will be looking at, is raycasting.

This method is extremely common in guns that have fast moving bullets that rarely change trajectory change over time.

Instead of creating a bullet object and sending it through space, we instead send a ray starting from the barrel/muzzle of the gun forwards. We set the raycast’s origin to the starting position of the bullet, and based on the length we can adjust how far the bullet ‘travels’ through space.

Note

While I cannot say for sure this is the case, these games probably use raycasts in some form or another: (These are entirely from my observations. They may be entirely wrong. I have never worked on any of the following games)

Halo (Assault rifles, DMRs, battle rifles, covenant carbine, spartan laser, and more)

Destiny (Auto rifles, pulse rifles, scout rifles, hand cannons, machine guns, and more)

Call of Duty (Assault rifles, light machine guns, sub machine guns, pistols, and more)

Battlefield (Assault rifles, SMGs, carbines, pistols, and more)

One huge advantage for this method is it’s light on performance. Sending a couple hundred rays through space is way easier for the computer to calculate than sending a couple hundred bullet objects.

Another advantage is we can instantly know if we’ve hit something or not exactly when we call for it. For networking this is important because we do not need to sync the bullet movements over the Internet, we only need to send whether or not the raycast hit.

```

Ondsinet

2019-02-01 14:28:51 UTC

```Raycasting does have some disadvantages though. One major disadvantage is we cannot easily cast a ray in anything but a linear line. This means we can only fire in a straight line for however long our ray length is. You can create the illusion of bullet movement by casting multiple rays at different positions, but not only is this hard to implement in code, it is also is heavier on performance.

Another disadvantage is we cannot see the bullet. With bullet objects we can actually see the bullet travel through space if we attach a mesh to it, but because raycasts happen instantly, we do not have a decent way of showing the bullets. You could draw a line from the origin of the raycast to the point where the raycast collided, and that is one popular way of showing raycasts. Another way is simply not drawing the raycast at all, because theoretically the bullets move so fast our eyes could not see it anyway.```