# Client-Side Prediction framework _Made with [Mirror](https://mirror-networking.com/) for Unity_ This repository contains a garbage free client-side prediction framework, implemented in two different example scenarios: * [CharacterController](https://github.com/GiovanniZambiasi/Client-Side-Prediction/raw/master/#charactercontroller) * [Rigidbodies](https://github.com/GiovanniZambiasi/Client-Side-Prediction/raw/master/#rigidbody) _*WIP_ My goal is to develop an easy-to-use, garbage free framework to streamline the implementation of client-side prediction across any scenario that needs it. Though the current solution is still a work-in-progress, it works, and will hopefully avoid the headache of adding all the boilerplate code to all predictive clients your project needs. ## What is client-side prediction? Client-side prediction is a way to hide the issues of a bad internet connection. It'll stop input lag, and minimize the jitteriness of packet loss. For more information, I recommend [this](https://www.gabrielgambetta.com/client-side-prediction-server-reconciliation.html) article. ## DEMO ### CharacterController The [CharacterController](https://docs.unity3d.com/Manual/class-CharacterController.html) example features a simple controller that moves and has gravity applied. It can be extended quite easily though. I recorded a demo where I simulated 150ms of lag using [clumsy](https://jagt.github.io/clumsy/), and then applied a packet loss rate of 2%. Here's the [Video](https://youtu.be/EVwhoD6A6J0):
[![CC_Example](https://camo.githubusercontent.com/a2b930ac1fef53f645e5dd5bfbb679f0782d5370557be60c52336b3840bf6076/68747470733a2f2f692e7974696d672e636f6d2f616e5f776562702f455677686f443641364a302f6d7164656661756c745f36732e776562703f64753d33303030267371703d43504b48375038462672733d414f6e34434c425a6862334a71422d495068745570536a714c4b547766664c326a67)](https://youtu.be/EVwhoD6A6J0)
Note that the demo doesn't include any kind of entity interpolation, so the server's client just flickers in the client's screen when packet loss is enabled. The client's cube however is fully predictive. ### Rigidbody The rigidbody example scenario is still a work in progress. The bodies are simulated via the [PhysicsScene.Simulate](https://docs.unity3d.com/ScriptReference/PhysicsScene.Simulate.html) method. When not simulating, the client is moved to an empty scene created in runtime called "Idle". This implementation is simple and easy to understand, but **it stops the clients interacting with one another**. I recorded a demo where I simulated 150ms of lag using [clumsy](https://jagt.github.io/clumsy/), and then applied a packet loss rate of 2%. Here's the [Video](https://youtu.be/lxiUcX3ZgyI):
[![RB_EXAMPLE](https://camo.githubusercontent.com/31c1a3f36ab06d63185114a5962b776e7960b34f2fdb30c86fa81df101260959/68747470733a2f2f692e7974696d672e636f6d2f76692f6c7869556358335a6779492f687164656661756c742e6a70673f7371703d2d6f61796d77455a4350594245496f4253465879713471704177734941525541414968434741467741513d3d2672733d414f6e34434c4446324d4e54534b745649482d3134467843353479685f4138367541)](https://youtu.be/lxiUcX3ZgyI)
Note that the demo doesn't include any kind of entity interpolation, so the server's cube just flickers in the client's screen when packet loss is enabled. The client's cube however is fully predictive. ## How to use The developer needs to fulfill 5 steps to implement prediction: * [State](https://github.com/GiovanniZambiasi/Client-Side-Prediction/raw/master/#1-implement-state) * [Input](https://github.com/GiovanniZambiasi/Client-Side-Prediction/raw/master/#2-implement-input) * [Messenger](https://github.com/GiovanniZambiasi/Client-Side-Prediction/raw/master/#3-implement-the-messenger) * [Client](https://github.com/GiovanniZambiasi/Client-Side-Prediction/raw/master/#4-implement-the-client) * [Prediction](https://github.com/GiovanniZambiasi/Client-Side-Prediction/raw/master/#5-implement-the-prediction) ### 1) Implement _state_ Create your state block. This block should represent a snapshot of your client at any given time _(position, rotation, speed, for example)_.

The state *must* implement the `INetworkedClientState` interface: ```cs public interface INetworkedClientState : IEquatable { ///

/// The tick number of the last input packet processed by the server ///

uint LastProcessedInputTick { get; } } ``` The only requirement is to create a `uint` field to store the _last processed input tick_. This is important because the prediction will set the client at that state, and then reprocess all inputs from that tick till the most recent tick. It's recommended to create your state as a struct to avoid heap allocations.

Example: ```cs public struct RigidbodyState : IEquatable, INetworkedClientState { public uint LastProcessedInputTick => lastProcessedInputTick; public Vector3 position; public Vector3 velocity; public Vector3 angularVelocity; public Quaternion rotation; public uint lastProcessedInputTick; public RigidbodyState(Vector3 position, Vector3 velocity, Vector3 angularVelocity, Quaternion rotation, uint lastProcessedInputTick) { this.position = position; this.velocity = velocity; this.angularVelocity = angularVelocity; this.rotation = rotation; this.lastProcessedInputTick = lastProcessedInputTick; } public bool Equals(RigidbodyState other) { return position.Equals(other.position) && velocity.Equals(other.velocity) && angularVelocity.Equals(other.angularVelocity) && rotation.Equals(other.rotation); } public bool Equals(INetworkedClientState other) { return other is RigidbodyState __other && Equals(__other); } } ``` ### 2) Implement _input_ Create your input block. This block should contain: * Information about your input in a given tick * The amount of time the input is meant for _(delta time)_ Similarly to the _state_ block, it's recommended to use structs for your _input_ to avoid heap allocations.

The _input_ must implement `INetworkedClientInput` ```cs public interface INetworkedClientInput { ///

/// The amount of time the input was recorded for ///

float DeltaTime { get; } ///

/// The tick in which this input was sent on the client ///

uint Tick { get; } } ``` The two required fields are: * `DeltaTime`: the amount of time that has passed between ticks when this input state was recorded. This is necessary because the client's application can be running at a framerate lower than the target framerate. * `Tick`: what the current tick number is. This is used by the server while sending states to the clients. The state will be _stamped_ with the Tick number of the last processed input block. The client will then use the _stamp_ to determine which input ticks to predict. Both fields will be supplied by the `NetworkedClient` when recording state.

Example: ```cs public struct RigidbodyInput : INetworkedClientInput { public float DeltaTime => deltaTime; public uint Tick => tick; public Vector2 movement; public float deltaTime; public uint tick; public RigidbodyInput(Vector2 movement, float deltaTime, uint tick) { this.movement = movement; this.deltaTime = deltaTime; this.tick = tick; } } ``` ### 3) Implement the _Messenger_ The _Messenger_ is a component that's really a workaround. Because Mirror doesn't support generic arguments in a _NetworkBehaviour_, the messaging part of the `NetworkedClient` needs to be encapsulated in a separate component. The _Messenger_ is an interface: ```cs public interface INetworkedClientMessenger where TClientInput : INetworkedClientInput where TClientState : INetworkedClientState { event System.Action OnInputReceived; TClientState LatestServerState { get; } void SendState(TClientState state); void SendInput(TClientInput input); } ```

To implement it, the developer needs to create a `NetworkBehaviour` that implements the interface, using their _state_ and _input_ blocks as the `TCLientInput` and `TClientState` generic parameters, respectivelly: ```cs public class NetworkedRigidbodyMessenger : NetworkBehaviour, INetworkedClientMessenger ```

The `SendState` method should call an _Rpc_ and send the provided _state_ to the clients: ```cs public void SendState(RigidbodyState state) { RpcSendState(state); } [ClientRpc(channel = Channels.DefaultUnreliable)] // It's recommended to use the unreliable channel, since this message will be sent frequently void RpcSendState(RigidbodyState state) { _latestServerState = state; } ```

The `SendInput` method should call a _Cmd_ and send the provided _input_ to the server: ```cs public void SendInput(RigidbodyInput input) { CmdSendInput(input); } [Command(channel = Channels.DefaultUnreliable)] // It's recommended to use the unreliable channel, since this message will be sent frequently void CmdSendInput(RigidbodyInput state) { //... } ```

Lastly, the _Messenger_ *must* implement an ``Action`` of the input type, and invoke it whenever an _input_ message is received: ```cs public void SendInput(RigidbodyInput input) { CmdSendInput(input); } [Command(channel = Channels.DefaultUnreliable)] void CmdSendInput(RigidbodyInput state) { OnInputReceived?.Invoke(state); } ``` ### 4) Implement the _Client_ The _Client_ is an ``abstract class`` that the developer needs to inherit from. It'll be the main part of your prediction. The _Client_ is responsible for controlling the ticks, recording the _state_ and processing the _inputs_. It'll also reference the _Messenger_ in order to send the networked messages. ```cs public abstract class NetworkedClient : MonoBehaviour, INetworkedClient where TClientInput : INetworkedClientInput where TClientState : INetworkedClientState ```

To implement the _Client_, the developer needs to inherit from ``NetworkedClient``, using their _state_ and _input_ blocks as the `TCLientInput` and `TClientState` generic parameters, respectivelly: ```cs public class NetworkedRigidbody : NetworkedClient ```

The _Client_ has 3 abstract methods that need to be implemented: __a)__ ``void SetState(TClientState)``: Responsible for setting the object to a particular tick: ```cs public override void SetState(RigidbodyState state) { _rigidbody.position = state.position; _rigidbody.velocity = state.velocity; _rigidbody.rotation = state.rotation; _rigidbody.angularVelocity = state.angularVelocity; } ```

__b)__ ``void ProcessInput(TClientInput)``: Responsible for applying the _input_ to the client for an amount of time _(``DeltaTime`` provided in the input block)_: ```cs public override void ProcessInput(RigidbodyInput input) { var __force = new Vector3(input.movement.x, 0f, input.movement.y); __force *= _speed * input.deltaTime; _rigidbody.AddForce(__force, ForceMode.Impulse); _physicsScene.Simulate(input.deltaTime); } ```

__c)__ ``TClientState RecordState``: Responsible for creating the _state_ block at the current time: ```cs protected override RigidbodyState RecordState(uint lastProcessedInputTick) { return new RigidbodyState(_rigidbody.position, _rigidbody.velocity, _rigidbody.angularVelocity, _rigidbody.rotation, lastProcessedInputTick); } ``` ### 5) Implement the _Prediction_ The _prediction_ is an abstract class that the developer needs to inherit from. It'll be responsible for the local client's behaviour. It does two things: * Record the _input_ block * _Predict_ the outcome of said _input_ ```cs public abstract class ClientPrediction : MonoBehaviour where TClientInput : INetworkedClientInput where TClientState : INetworkedClientState ```

To implement, the developer needs to inherit from ``ClientPrediction``, using their _state_ and _input_ blocks as the `TCLientInput` and `TClientState` generic parameters, respectivelly: ```cs public class RigidbodyPrediction : ClientPrediction ```

The only method that needs to be implemented is `TCLientInput GetInput(float deltaTime, uint currentTick);`. The developer will be responsible for storing the `deltaTime` and `currentTick` values in the _input_ block: ```cs protected override RigidbodyInput GetInput(float deltaTime, uint currentTick) { var __movement = new Vector2 { x = Input.GetAxis("Horizontal"), y = Input.GetAxis("Vertical") }; return new RigidbodyInput(__movement, deltaTime, currentTick); } ```
At every tick, the component will check if any new states have been received by the server. If so, the client will be set to that new state, and all recorded input packets from that point onwards will be re-simulated. This fulfills the _client-side prediction_. ### Finally... Once the 5 previous steps have been completed, all that's left to do is assemble your object in unity. For that, the developer will need to create a prefab which contains, at least: * The `NetworkedClient` component created at step 4 * The `ClientPrediction` component created at step 5 * The `Messenger` component created at step 3 * A `NetworkIdentity` component ![Prefab_Example_1](https://camo.githubusercontent.com/b8a707f720bac199b6958a24753d4cba54fabec8537ecb603d13c0da0f5f869c/68747470733a2f2f692e696d6775722e636f6d2f525173367453692e706e67)
Then, the _dependencies_ of `NetworkedClient` and `ClientPrediction` need to be fulfilled: ![Prefab_Example_2](https://camo.githubusercontent.com/a5d6323df4a6f3f014712c65419dd5f2a414ea0ddf68353df418fc1b3f339010/68747470733a2f2f692e696d6775722e636f6d2f764e58706c504b5f642e776562703f6d617877696474683d37363026666964656c6974793d6772616e64)