If you’ve had an interest in fighting games nowadays, you’ve probably heard the term “rollback netcode” thrown around the grapevine. Fighting game developers such as Arc System Works are making this feature a big selling point in some of its recent fighting games, and even Riot Games has tapped into the rollback netcode train for its upcoming fighting game, Project L.
Fighting game players are always on the hunt for fast, consistent online connections. As many players aren’t able to commute to offline events and play games with other players, online netplay is often the only option afforded to them. For fighting games, in particular, a good connection means you’ll be able to execute your inputs, land your combos, and react to enemy mixups.
This means the best possible online play is essential for retaining a healthy player base for a game. Luckily, in recent years, development in creating a smoother, faster online experience has blossomed in the form of ‘rollback netcode.’ To understand what rollback netcode is, it’s important to understand the difference between rollback, and delay-based netcode.
What is delay-based netcode?
First, the basics of a fighting game are how attacks are measured. It’s almost like a measure of time in fighting games. For instance, an attack for a character may come out in 3 frames, while another character’s slower attacks may come out in 5 frames. When you press a button on your controller, the computer reads it as an input and executes the attack. Logically, when two players press buttons, the game receives both inputs and processes them at the same time.
This is consistent in offline play and is why fighting game players much prefer to practice on an offline network. If you think about it logically, there is always a delay when information is sent over a network. Fighting games need to compensate for this delay so that your inputs don’t arrive late and arrive at the same time as the enemy player. (Imagine if you pressed a button, and you had to wait a second before your attack came out, while your opponent manages to get their attacks out earlier.)
Delay-based netcode was the previous, dominant way to compensate for this delay over the network. Essentially, what happens is, the game will artificially delay the inputs for both the remote and local player. For example, if a move is supposed to come out in 5 frames, the game might artificially force it to come out in 8 frames. This same limitation is placed on both players. Players who are used to playing offline will feel this difference, which is why netplay is often derided in the community. (This is a simplification of what actually happens.)
In theory, if the internet was a consistent battlefield where fluctuations were extinct, this wouldn’t be so bad. There are times when delay-based netcode runs well, and arguably better than rollback netcode. (This is considering the distance between two players.) However, as we all know, the internet is not a level playing field. Fluctuations happen all the time.
Imagine if there’s a spike in your connection, and the information from your controller can’t reach the network. You press the A button, but because of a spike in your internet, this cannot reach the enemy player in time. What happens? The game freezes and lags, because this is the only way to ensure that all inputs arrive at the same time.
What is rollback netcode?
So what’s rollback netcode, and why have fighting game players rallied behind it as the superior handling of online play? Remember how the Super Smash Bros. community freaked out after the developers refused to incorporate rollback?
Essentially, rollback netcode eliminates the delay by predicting your inputs. The game will attempt to predict your input by itself and will show that input to the enemy player. For example, if the game expects you to use Ryu’s Fireball at the enemy, that’s what the game will show the enemy. However, imagine if you instead used a different attack? The game will “rollback,” and adjust what actually happened. The game rewinds to a different state, one where your other attack was actually executed.
So what’s the benefit of rollback netcode? Wouldn’t this mean the game would constantly rewind into different states? In reality, most of the time, this rewind happens in such a quick amount of time, it’s hard to even notice. If there’s a huge lag spike and the game correctly predicts all the inputs at the time, then you wouldn’t notice a change in gameplay.
In fact, games often predict certain frames in the future with great accuracy. Imagine that you are blocking a long string of enemy pressure. What is the game’s best guess of what you’ll do in the future? Will you try and contest the enemy or will you continue to block? In most cases, you will choose to block, and the game will correctly predict that.
When implemented well, rollback netcode can create a much faster, smoother game experience for all. Guilty Gear: Strive has a great online netcode, and tournaments between the United States and Japan have been held to great success. This would be impossible in a delay-based netcode, as the delay would be too strong.
Ars Technica has a much deeper dive into what makes rollback netcode so great and dives deeper into the cognitions of how these two netcode styles work. If you’re interested, check out their article. Youtuber Core-A Gaming also has a helpful video on rollback netcode, including visual examples and interviews with game developers. You can visit his channel or check out the video below: