mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-10-17 20:19:20 +02:00
Hirek193
c0dbf99f1a
Until now the server ran the physics of everything and a client re-ran it from the server's frame times, corrected a few times a second. That is the worst of both: the client's own train never moved smoothly, its controls answered a round trip late, and the two copies still sat metres apart between corrections. Simulation authority now follows the train: - the first person aboard a train runs its physics on their own machine, and what they produce is what the rest of the session is told about it. A train with nobody in it belongs to the host. Every peer works the owner out the same way, from the crew of its lowest numbered car, so nobody has to be told - a peer never applies corrections to a train it runs itself. Its own physics is the authority on it, and overwriting that is precisely what made the owner's ride stutter - a client publishes the state of its own trains upstream, ten times a second. The server takes it, filtered so a peer can only move the trains it is entitled to move, and passes it on to everybody else in its own stream - so the picture is: your train is smooth for you and may stutter for the others; their trains may stutter for you and are smooth for them Two things follow from it: - commands for the train you run take effect the moment you press the key instead of after a trip to the server and back. They are still sent, so everybody else sees them, and the echo is dropped when it returns - the client no longer replays the server's frame times out of a jitter buffer. It runs on its own clock, like the host does, and simply carries out the commands as they arrive. Playing back somebody else's frame times meant the world ran at the wrong speed whenever the two machines drew at different rates, and every buffered frame sat between the player and their controls Also: the server only sends a frame when it has commands in it, or every tenth one to carry the tick, instead of one per rendered frame.
76 lines
2.5 KiB
C++
76 lines
2.5 KiB
C++
/*
|
|
This Source Code Form is subject to the
|
|
terms of the Mozilla Public License, v.
|
|
2.0. If a copy of the MPL was not
|
|
distributed with this file, You can
|
|
obtain one at
|
|
http://mozilla.org/MPL/2.0/.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <cstdint>
|
|
#include <string>
|
|
|
|
#include "network/entities.h"
|
|
|
|
namespace network
|
|
{
|
|
|
|
// layout of the snapshot container. a reader refuses a blob it does not understand
|
|
constexpr uint32_t SNAPSHOT_VERSION = 2;
|
|
|
|
// the sections a snapshot is built from. a reader skips over any id it does not know,
|
|
// which is what makes the format extensible: a peer built before a section existed can
|
|
// still read a newer snapshot and simply ignores what it has no use for
|
|
enum snapshot_chunk : uint16_t
|
|
{
|
|
// tick, clock, weather and (in a full snapshot) the state of the random engine
|
|
SNAPSHOT_SESSION = 1,
|
|
// where every vehicle is, what its controls and appliances are set to, and what its
|
|
// brakes are doing
|
|
SNAPSHOT_VEHICLES = 2,
|
|
// who is working which vehicle
|
|
SNAPSHOT_CREWS = 3,
|
|
// contents of the memory cells - this is what signalling reads
|
|
SNAPSHOT_MEMCELLS = 4,
|
|
// which way the switches are thrown
|
|
SNAPSHOT_SWITCHES = 5
|
|
};
|
|
|
|
// what a peer is meant to do with the blob it received
|
|
enum class snapshot_mode
|
|
{
|
|
// the peer is coming in cold and takes the world as it is given
|
|
join,
|
|
// routine correction on top of a simulation that is already running
|
|
correction
|
|
};
|
|
|
|
struct snapshot_result
|
|
{
|
|
bool ok{false};
|
|
// how far the worst vehicle was from where the authority says it is
|
|
double worst_position_error{0.0};
|
|
uint32_t vehicles{0};
|
|
uint32_t repositioned{0};
|
|
};
|
|
|
|
// packs the state of the world. only ever called on the authority.
|
|
// a full snapshot carries everything and is what a joining peer gets; otherwise only what
|
|
// has changed since the last one goes out, which is what keeps the routine correction
|
|
// stream small
|
|
// OwnedOnly limits it to the trains this peer runs itself and leaves out everything that
|
|
// is not a vehicle; that is what a client sends upstream about its own train
|
|
std::string take_snapshot(bool Full, bool OwnedOnly = false);
|
|
|
|
// restores state handed to us. vehicles this peer runs itself are never touched - their
|
|
// physics is the authority, not the other way round. Owner, when given, limits the update
|
|
// to the trains that peer is entitled to move, so a client cannot shove anybody else's
|
|
snapshot_result apply_snapshot(std::string const &Blob, snapshot_mode Mode, PeerId Owner = PEER_NONE);
|
|
|
|
// forgets what was last sent, so that the next delta comes out complete
|
|
void reset_snapshot_history();
|
|
|
|
} // namespace network
|