mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-10-18 06:49:18 +02:00
Hirek193
0b75e701fc
Second live test. Four things, three of them the same mistake seen from different angles: the session was reasoning about single vehicles where it should have been reasoning about trains. - a peer may now operate anything coupled into the set it is sitting in. This is what "cabchangebackward rejected: not a member of the crew of that vehicle" was: the crew was recorded against one car of a four-car unit, and the cab switch addressed another - every vehicle gets a network id, not only the ones worth driving. Commands are addressed by that id, and a player has to be able to walk into any car of their train. "peer 3 cannot take en71-017rb_4: no such vehicle in this session" was the driving trailer of an EN71 - a full desk, no engine, and nobody assigned to it, so the old test missed it. Having a driving position is what counts now, engine or not - the roster groups vehicles into the trains they are coupled into and the lobby lists one row per train. Coupling is worked out afresh every time, so a train that comes apart becomes two, and because a crew entry sits on the car its player occupies, each half keeps the people who were riding in it - walking to another car of your own train is not a new claim and asks nothing of the crew capacity, which counts people per train Positional correction never actually did anything: it identified a track by name, and most track in a scenery has none, so the lookup returned nothing and place_on_track() was never reached. The client sat 178 m out of place for minutes, reporting four vehicles "put back on the rails" every time while moving none of them. Tracks now travel as their index in the path table, which comes from the scenery file and is therefore the same on every peer. Also from the test: - the camera jumped in and out of the cab on the client whenever the host reversed, because the correction was forcing the server's CabActive and CabOccupied onto it. Which cab somebody sits in is theirs alone - two people sharing a vehicle each have their own - so it is no longer replicated - the correction no longer touches the control positions of the train the local player is working. Their crew's commands reach every peer on their own, and snapping a lever back a fraction of a second after it was moved is what made the reverser look dead - the frame buffer was sized for the old lockstep, up to sixty frames deep. Every frame in it is input lag, so it is down to twelve with a target of one - asking the AI of a vehicle to step aside is given five tries and then said once, instead of every thirty frames forever; and a resync request now has a real cooldown
124 lines
4.8 KiB
C++
124 lines
4.8 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 <vector>
|
|
#include <unordered_map>
|
|
|
|
class TDynamicObject;
|
|
|
|
namespace network
|
|
{
|
|
|
|
// identifies a participant of the session. the host is a participant like any other,
|
|
// so that peer/crew/permission handling does not need a special case for it
|
|
using PeerId = uint32_t;
|
|
constexpr PeerId PEER_NONE = 0;
|
|
constexpr PeerId PEER_HOST = 1;
|
|
// remote peers are numbered from here up
|
|
constexpr PeerId PEER_FIRST_REMOTE = 2;
|
|
|
|
// identifies a vehicle for the whole session. unlike TTrain::id() this does not depend
|
|
// on the order in which a particular peer happened to create its trains
|
|
using NetworkEntityId = uint32_t;
|
|
constexpr NetworkEntityId ENTITY_NONE = 0;
|
|
|
|
// how many people may share one vehicle. the crew itself is a plain container,
|
|
// so raising this number does not call for a structural change
|
|
constexpr uint8_t CREW_CAPACITY = 2;
|
|
|
|
// authoritative description of a single vehicle, as published by the server.
|
|
// every vehicle is listed, not only the ones worth driving: commands are addressed by
|
|
// this id, and a player may walk into any member of the train they are working
|
|
struct vehicle_entry
|
|
{
|
|
NetworkEntityId id{ENTITY_NONE};
|
|
std::string name;
|
|
// the train this vehicle is currently coupled into, named by the lowest id in the set.
|
|
// a player belongs to a train, not to a single car, so this is what the crew, the
|
|
// permissions and the lobby all work with. it is recomputed as vehicles couple and
|
|
// uncouple, which is what splits a crew between the halves of a train that came apart
|
|
NetworkEntityId consist_id{ENTITY_NONE};
|
|
// how many vehicles that train has, and whether this entry is the one that stands for
|
|
// it in the lobby
|
|
uint8_t consist_size{1};
|
|
bool consist_lead{false};
|
|
// crew of the whole train, not of this vehicle alone
|
|
uint8_t crew_count{0};
|
|
uint8_t crew_capacity{CREW_CAPACITY};
|
|
bool ai_active{false};
|
|
bool claimable{false};
|
|
// has a driving position of its own
|
|
bool drivable{false};
|
|
|
|
bool operator==(vehicle_entry const &Other) const
|
|
{
|
|
return id == Other.id && name == Other.name && consist_id == Other.consist_id && consist_size == Other.consist_size && consist_lead == Other.consist_lead &&
|
|
crew_count == Other.crew_count && crew_capacity == Other.crew_capacity && ai_active == Other.ai_active && claimable == Other.claimable &&
|
|
drivable == Other.drivable;
|
|
}
|
|
bool operator!=(vehicle_entry const &Other) const { return !(*this == Other); }
|
|
};
|
|
|
|
// maps stable network ids onto the vehicles of the loaded scenario.
|
|
// the server owns the numbering and publishes it; a client binds the received ids to
|
|
// its own copy of the scenario by vehicle name, which keeps the runtime protocol on ids
|
|
class entity_registry
|
|
{
|
|
public:
|
|
// server side: builds the numbering from the loaded scenario. vehicles are ordered by
|
|
// name so that the result does not depend on the order the scenario happened to spawn them
|
|
void build();
|
|
// client side: takes over the numbering published by the server
|
|
void adopt(std::vector<vehicle_entry> const &Entries);
|
|
// server side: refreshes the volatile part of the published entries
|
|
void refresh();
|
|
void clear();
|
|
|
|
bool empty() const { return m_entries.empty(); }
|
|
std::vector<vehicle_entry> const &entries() const { return m_entries; }
|
|
|
|
NetworkEntityId id_of(std::string const &Name) const;
|
|
NetworkEntityId id_of(TDynamicObject const *Vehicle) const;
|
|
// the train a vehicle belongs to, and everything coupled into it
|
|
NetworkEntityId consist_of(NetworkEntityId Id) const;
|
|
std::vector<NetworkEntityId> consist_members(NetworkEntityId Consist) const;
|
|
std::string name_of(NetworkEntityId Id) const;
|
|
TDynamicObject *resolve(NetworkEntityId Id) const;
|
|
vehicle_entry const *find(NetworkEntityId Id) const;
|
|
|
|
private:
|
|
void reindex();
|
|
|
|
std::vector<vehicle_entry> m_entries;
|
|
std::unordered_map<std::string, NetworkEntityId> m_byname;
|
|
std::unordered_map<NetworkEntityId, size_t> m_byid;
|
|
};
|
|
|
|
// session wide vehicle registry. stays empty outside of multiplayer
|
|
extern entity_registry Entities;
|
|
|
|
// hands out ids for connecting peers; PEER_HOST is reserved for the local participant
|
|
PeerId allocate_peer_id();
|
|
|
|
// true when this run takes part in a session at all, as host or as client
|
|
bool is_multiplayer();
|
|
// true when this peer decides what happens in the world. a standalone game and the host
|
|
// of a session do; a client does not, it only carries out what the server hands it
|
|
bool is_authority();
|
|
|
|
// true for vehicles that carry a driving position of their own. note that a driving
|
|
// trailer has one without having an engine, and without the scenario putting a driver in
|
|
bool is_drivable(TDynamicObject const *Vehicle);
|
|
|
|
} // namespace network
|