Phosphorus rounds are a good idea

How are balls simulated in video games?

I've been playing games like MW2 lately and as a programmer I tend to wonder how they make the game so immersive. For example, how they simulate the speed of the bullet.

  1. When an NPC fires a bullet from their weapon, does the bullet really move from their weapon to the specified target, or do they ignore that part entirely and just place a bullet hole on the target?

  2. If the bullet really flies from the weapon to the target, what is the speed at which it actually flies?


Most FPS games use raycasting for actual gameplay. Bullets travel instantly and hit the target when fired.

However, most games also use "fake" tracers. Every 3 shots or another interval a tracer is fired together with the bullet, the tracer is very fast, but not immediately. This is only done as a visual effect and does not have a direct impact on the game, but gives clues to the shooter, the shoe runner, and gives viewers an indication of shots.

Most of the games that use this type of ball physics are unrealistic as there are no ricochets, no ball fragments and when there is penetration it is usually linear.

Some games like ARMA II, STALKER (whole series) use a more realistic projectile physics with running time, ricochets and penetration with deflection angles. I believe these systems use raycasting, but with a limit set by the speed of the bullet. In these games, the muzzle velocity can be realistic like the ARMA II or look something like the STALKER.

I prefer realistic missile physics because guns fire projectiles, not lasers.

With bullets, they generally don't bother simulating the bullet that is actually going through the air and simply put a bullet hole on the target as soon as it is fired. Other things like missiles are slower * and the game shows them flying through the air.

On the short distances the balls move, together with the time lapse between the images, which would bring them to the target anyway between or within 1 image of the shooter.

* That is, slower than rockets in real life for the player to see them fly through the air.

I wrote the bullet code for PlanetSide. We had a few "hitscan" projectiles, but mostly simulated the projectiles as best we could, given the CPU limitations and the large number of bullets to be played at all times.

In the case of Hitscan, the impact is determined in the same frame as the input received, often using a single raycast. This is suitable for weapons like lasers or other extremely fast projectiles. We performed the hit scan by setting the initial speed of the projectile high enough that it would cross the board in a single tick.

Non-hitscan projectiles are ticked either on the graphic frame time or on a fixed time step, whereby calculations for acceleration (Think Rockets), gravity, air friction, steering (Think Heat Seeking Projectiles) etc. are applied. The goal is to generate the final position of the projectile for the time step. Once the start and end points are established, one or more rays can be cast to approximate the flight path and detect collisions that would have occurred during the flight.

What happens in a collision with both hits-scan and non-hits-scan projectiles depends on your projectile properties and the surface you are hitting. For example, you might hit a hard surface. In that case, you could check your rebound count and either adjust the position and speed per reflection or detonate the projectile when you hit your maximum rebound count. In this system, a missile only has a maximum rebound number of 0. You could hit a soft surface and then check your penetration to see if the projectile should penetrate the material, etc.

It was fun to write code. It is also very useful to write a good debug visualization of what is going on so that you can visually check flight paths, events, and so on.

It depends on the game and the accuracy / realism.

Synchronizing gun and damage models in multiplayer settings is quite difficult as you need to pinpoint exactly where and when a bullet was fired, whether it hit a target, and whether something else passed the path.

So my guess is that game developers try to simplify things wherever possible, either by treating some shots as instantaneous (so you just need to consider the location of all of them at any given point in time) or by limiting the range of the bullet. Fortunately, this often corresponds to real physics. For example, sniper rifles fire high-speed projectiles.

Many games can simulate a multi-level, multi-snapshot path of a slowly moving object (such as artillery, bombs, marking rounds, etc.). However, it is very costly and sync issues are more common, resulting in fun YouTube videos.

Another problem is games in which smaller "environments" are managed separately (e.g. each room is simulated separately) to create the illusion of a larger room. In these cases things can be correctly simulated within the confines of a "space" so that everyone in space is informed of the series of transitions in space that the sphere makes, but others outside of that environment are not.

Raycasting is often used for projectiles that are moving faster than the eye can see. A ray from the muzzle is calculated with the appropriate direction and compared to potential targets to determine what has been hit. This can be tricky with multiple rays and some extra calculations if you want to simulate things like throwing bullets and the like. You can also give the projects a speed and use that to add extra realism to the calculation (bullets are not immediately visible).

It depends on the implementation, but I know the Source Engine didn't use any physical bullets (projectile objects) at all, just a ray cast from the player to the target with a random "hit zone" circle (depending on larger or smaller radii) like quickly firing the gun and whether the player held the fire button), which center was the point the player aimed at after the actual beam was thrown by the player at the random point and depending on other factors (such as bullet "weight "and muzzle velocity (all internal numbers), object hits, etc.) the jet was thrown through several objects or until it hit the ground.

On the other hand, the Torque 3D Engine DID used actual projectile objects and the designer was able to influence their individual speed, mass and gravity modifiers. The motor only updated the values ​​every 32 milliseconds.


In addition to using projectile objects, the Torque 3D engine also enabled the use of raycasts as an alternative. (I've made several games where the "projectile" is actually a particle effect that doesn't have the support that projectile objects had, so ray throwing was required.)

In fact, many games use a GPU rendering hit test algorithm. Here's how it works:

1) Make an off-screen rendering of the current view where the entire terrain is black and each character is non-black in color. 2) Find the color of the pixel under the crosshair. > Apply player mapping and hit on that target.

This method has been used in games for years, largely because it is pixel perfect. If a single pixel of the player hat protrudes from behind a wall, you can hit it. IE if you can see it you can hit it. This kind of precision is next to impossible with simple jet casting techniques. Second, this type of test is extremely fast and can be done on the GPU.

Some games undoubtedly use realistic projectile physics taking into account projectile travel time and release, but I suspect most games don't, at least for NPCs.

For a game that makes a direct ball movement (not a drop), an imaginary line (vector) is drawn forward from the point of run. It then calculates what that line intersects with and registers a bullet point "hit" at that point. It can be a solid object such as a wall that an impact creates an effect on, e.g. B. an impact with a ball and a cloud of smoke. It can act on a fragile object, thereby breaking it, or it can act on a physical object and "kick" it. Or of course it hits the player or another NPC and causes a health hit. Hard core simulations model the projectile penetration into walls and trigger a hit effect on the exit side, which is likely to reduce the damage to the projectile upon exit.

Just so NPCs don't have a perfect target, many games add some sort of randomization to the vector to model the spread of the balls. This is what you would see in real life, where not all of the balls hit just where you aim, but in a pattern centered around the aiming point.

To visualize the expansion of the bullet, instead of a straight line (vector) imagine a cone emerging from the weapon. The actual direction of the floor is randomly chosen to be somewhere within this cone. If the shooter is really close to the target, the dispersion is low and the accuracy is high. When the target is far away, the spread of the cone increases, making the shooter less likely to hit the target.

This idea of ​​the cone of fire can be used to model shooter accuracy (skill), weapon accuracy, and other conditions. For example, a low level NPC could receive a low accuracy cone, whereas a high skill level NPC would have high accuracy. A player who shoots from the hip with a submachine gun has a wide cone of fire that narrows when they stop running or aim. By nature, sniper rifles have tighter cones than a pistol.

Speaking of Nexuiz source code, when I took a look, they actually didn't send a 'bullet' from point A to point B. The code shows where your gun is pointing when it is fired. If it is aimed at a person (and is an instant weapon) when you click fire, you have scored a hit.

It is also noteworthy how Nexuiz had the server-side ability to calculate hits on the client or on the server. If you suspect clients are cheating, you can switch to server-side hit calculations to mitigate this.

Another strategy is a mix of rendering and ray tracing. You don't necessarily have to render every sphere. For example, if your gun fires 30 rounds / second, one shot can produce a few hundred particles ... You can reduce the rendering by using a "tracer" effect, render every third shot and track the other two beams. The player still sees 10 rounds firing at the enemy per second.

Adjust the settings to suit your specific situation, rendering more for weapons with lower rate of fire and less for higher ones.

Don't forget that the frame rate can be an issue compared to the speed of the bullet. In some cases, the bullet can penetrate an object without hitting it if you haven't coded your physics engine well enough. There is a solution to this matter that I don't remember very well ...

Anyway, I think it can be very problematic to compensate for realistic bullets in a multiplayer environment, if not impossible, when the latency is longer than 30 or 50 ms.

One day the ISP might be a little more interested in latency and deliver different offers ... but without FTTH it's still a dream ...

In games like Bad Company, Battlefeild 3 and Stalker, I believe that the bullet is an actual single entity that is fired like a "missile". I just think ray tracing is necessary if the bullet hits the target right away. When the entity is itself in realistic spheres, it is just ticking to see if it hits someone.

When you watch video reruns in Call of Duty, you can actually faintly see an orange biped flying through the air towards its intended target, and attackinghobo actually has the correct answer for that for the most part.

If you want a richochet effect like Hobo, just play one of the Halo games. If you shoot a metal wall from a closer position, you can see the bullets ricocheting off the metal. The sniper leaves a trail to hit.

Retarted answer ended, I can go back later to fix.

The balls and all physics in the Stalker series of games use an open source library called the "Open Dynamics Engine".

The bullets fall with gravity and even bounce around walls and stuff very carefully if you are smart enough to bend a bullet off something to shoot someone you don't see but know their location. The sphere is an actual object model. This is the most realistic method I've ever seen. The ray trace method is not practical when you are going to large rooms. It would be okay to shoot a laser pistol though.

Other games that use BloodRayne 2, Call of Juarez, World of Goo, X-Moto, and OpenSimulator.

Another good choice would be the Bullet physics library.

It has been used in Grand Theft Auto 4, Red Dead Redemption, and more.

ps arma 2 uses an in-house physics engine, your next game arma 3 will use the physX physics engine

We use cookies and other tracking technologies to improve your browsing experience on our website, to show you personalized content and targeted ads, to analyze our website traffic, and to understand where our visitors are coming from.

By continuing, you consent to our use of cookies and other tracking technologies and affirm you're at least 16 years old or have consent from a parent or guardian.

You can read details in our Cookie policy and Privacy policy.