Who holds the characters

A multiplayer game decides early where the characters of the players live: inventory, skills, quests, achievements, the look. The Pulse plugins support two models. Pick one per game and tell the players which one it is.

  Server holds the characters Players hold their characters
Where the save is On the server (dedicated server or the host of a listen server) On the machine of every player
A player joins The server applies the player’s data from its own save The player brings the character from the own save
Cheating Only through bugs of the game: clients send ids and intents, the server checks everything Open: whoever edits the own save file or memory has any item
Good for Online worlds, competitive games, anything with trading between strangers Co-op among friends, drop-in sessions, carrying one character through many worlds

Server holds the characters

This is the model every Pulse plugin is built for and the safe default.

  • Clients only send requests with ids and intents (move this item, unlock this skill, place this part). The server checks them against its own state and answers with a result. Rate limits, open requests and the suspicion count of the request subsystem stop clients that flood the server.
  • Everything that changes several systems at once (a trade, crafting, a purchase) runs as an exchange: all or nothing, logged, checked by the spec group PulseFoundation.Exchange.Dupes.
  • The server saves the characters with the world. With PulseSave, players who leave are saved into the running save and get their data back when they join again (Player data in the PulseSave docs, Player.<player id>.*).
  • Clients never write saves of the session. A client that quits keeps nothing of its own; the host or server has it.

Players hold their characters

Each player saves the own character locally and brings it into the session of a friend. The server takes the character as it comes, so a player can cheat by editing the own save. That is fine among friends and wrong anywhere else.

  • Save only the character on the client (the components on the pawn, player state and controller of the local player), never the world of somebody else.
  • Send the bytes of the character to the server once on joining, with a request of the game (an own server RPC with a request id, answered with a result). The server loads them into the components of that player with the saveable interface (IPulseByteSaveable::LoadFromBytes) and then plays on with the usual requests.
  • The server should still check what it takes: version and size of the bytes (the serialization headers), values in their bounds, unlocks that need content of this world. Reject what does not fit with a reason instead of loading half of it.
  • When the player leaves, the server sends the current state back (or the client saves what was replicated to it), so progress made in the session comes home.
  • Turn off what the server would do otherwise: with PulseSave, bKeepPlayerData off, so the host does not keep and apply its own copy of the guests.

Mixing both in one game is possible (the host’s own character from the host’s save, guests bring theirs), but then the game holds the characters of the guests in the second model: say so in the menu where players pick a session.

What Pulse does not do

Pulse has no anti-cheat for files, memory, movement or speed. It keeps the server side honest (requests, exchanges, the server recomputes everything) and leaves the choice of the model to the game.


PulseFoundation plugin documentation.

This site uses Just the Docs, a documentation theme for Jekyll.