When I started working on networking for my multiplayer game, I wanted a clear distinction between something a client wants to happen and something the server has decided happened.
For example, imagine a player trying to purchase an item.
The client can request the purchase, but it shouldn't be responsible for deciding whether the player has enough money, whether the item is available, or whether the transaction actually happened.
Those decisions belong to the server.
This was one of the ideas that led me to design INER (Intention, Notification, Event, Response).
Requests aren't facts
INER is a communication protocol organized around four message types.
Two are particularly important for this distinction:
- Intention: A client requests an operation from the authoritative server.
- Event: The server communicates something authoritative to a client.
An Intention represents what a client wants to do. It doesn't imply that the requested operation is valid or that it will succeed.
An Event, on the other hand, communicates information from the authoritative side.
This distinction may seem obvious, but I wanted it to be part of the communication model itself.
What happens when the server rejects something?
INER also defines Responses.
Rather than treating every request as a simple success-or-failure operation, the protocol supports four response categories:
- Approved: The requested operation was accepted.
- Denied: The operation was rejected, with a reason code.
- Partial: The operation was partially accepted, with a reason code and additional data.
- Failure: The operation failed.
This allows applications to distinguish different outcomes without inventing their own response structure for every interaction.
For example, a server could deny a purchase because the player lacks sufficient resources.
Or it could partially fulfill an operation when the game's rules allow it.
The exact meaning of these results is determined by the application, but INER provides a common structure for communicating them.
Matching responses to requests
Another consideration was identifying which request a response belongs to.
INER includes a correlation identifier in Intention messages.
The client supplies a 16-bit sequential identifier, and the server combines it with a 16-bit client identifier to establish the full correlation identifier on the authoritative side.
This helps associate responses with their corresponding intentions.
The idea is to keep request correlation explicit without introducing an unnecessarily complicated messaging model.
Not every message needs a response
INER also supports Notifications.
Unlike Intentions, Notifications don't expect a Response.
This is useful for information that doesn't require a request-result interaction.
I wanted the protocol to distinguish between requesting an operation and simply communicating information, because those two situations have different semantics.
Where INER fits
INER doesn't implement sockets, manage connections, or replace a networking transport.
It defines the structure and meaning of application messages.
I've implemented it in LightnerX, my open-source C++ networking library for multiplayer game development, which uses Valve's GameNetworkingSockets as its transport layer.
Keeping these responsibilities separate allows the communication model to focus on message semantics while the underlying networking library handles transport.
I'm still developing and refining the project, and I'd be interested in feedback from people who have worked on multiplayer protocols or authoritative client-server architectures.
Do you think explicitly separating client intentions from authoritative server events makes multiplayer code easier to maintain, or does it introduce unnecessary complexity?
Top comments (0)