eu07/maszyna
17
0
Fork 0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-10-17 14:29:20 +02:00
Code Issues 151 Wiki Activity

multiplayer: a player works a train, not a car - and put the corrections right

Browse Source 
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
This commit is contained in:
Hirek
2026-09-06 23:39:13 +00:00
parent a72c3292ad
commit 0b75e701fc
9 changed files with 357 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

81
network/session.cpp
View File

@@ -70,8 +70,7 @@ command_verdict validate_command(PeerId Peer, user_command Command, uint32_t Rec
if (target == command_target::vehicle)
{
// a player works the controls of the vehicle they are on, and of no other
return Crews.is_member(Peer, (NetworkEntityId)(Recipient & 0xffff)) ? command_verdict::accepted : command_verdict::not_in_crew;
return may_control(Peer, (NetworkEntityId)(Recipient & 0xffff)) ? command_verdict::accepted : command_verdict::not_in_crew;
}
if (target == command_target::simulation)
@@ -93,11 +92,24 @@ claim_result claim_by_name(PeerId Peer, std::string const &Vehicle, NetworkEntit
return claim_result::unknown_vehicle;
auto const previous = Crews.vehicle_of(Peer);
if (previous == Entity)
return claim_result::already_member;
if ((previous != ENTITY_NONE) && (Entities.consist_of(previous) == Entities.consist_of(Entity)))
{
// walking to another car of the train you are already working is not a new claim,
// so it asks nothing of the capacity. the seat still moves, because which car a
// player sits in decides which half they keep when the train comes apart
Crews.leave(Peer, previous);
Crews.take_seat(Peer, Entity);
return claim_result::granted;
}
auto const result = Crews.claim(Peer, Entity);
if ((result == claim_result::granted) && (previous != ENTITY_NONE) && (previous != Entity))
if ((result == claim_result::granted) && (previous != ENTITY_NONE))
{
// nobody works two vehicles at once
// nobody works two trains at once
Crews.leave(Peer, previous);
}
@@ -152,6 +164,21 @@ void filter_commands(PeerId Peer, command_queue::commands_map &Commands)
}
}
bool may_control(PeerId Peer, NetworkEntityId Entity)
{
auto const seat = Crews.vehicle_of(Peer);
if (seat == ENTITY_NONE)
return false;
auto const train = Entities.consist_of(Entity);
if (train == ENTITY_NONE)
return false;
// the whole set the player is sitting in, so that the desk of a driving trailer works
// on the motor cars behind it and the cab switches of a multiple unit go through
return Entities.consist_of(seat) == train;
}
vehicle_crew &crew_registry::entry(NetworkEntityId Id)
{
auto lookup = m_vehicles.find(Id);
@@ -178,7 +205,8 @@ claim_result crew_registry::claim(PeerId Peer, NetworkEntityId Id)
if (std::find(vehicle.crew.begin(), vehicle.crew.end(), Peer) != vehicle.crew.end())
return claim_result::already_member;
if (vehicle.crew.size() >= published->crew_capacity)
// capacity counts the people on the whole train, not on this one car
if (published->crew_count >= published->crew_capacity)
return claim_result::crew_full;
if (vehicle.crew.empty())
@@ -373,6 +401,23 @@ void crew_registry::mirror(NetworkEntityId Id, std::vector<PeerId> const &Crew)
entry(Id).crew = Crew;
}
void crew_registry::take_seat(PeerId Peer, NetworkEntityId Id)
{
auto &vehicle = entry(Id);
if (std::find(vehicle.crew.begin(), vehicle.crew.end(), Peer) != vehicle.crew.end())
return;
if (vehicle.crew.empty())
{
TDynamicObject const *dynamic = Entities.resolve(Id);
vehicle.ai_before_claim = (dynamic != nullptr && dynamic->Mechanik != nullptr && dynamic->Mechanik->AIControllFlag);
vehicle.ai_restore_pending = false;
}
vehicle.crew.emplace_back(Peer);
m_pending.emplace_back(Id);
}
std::vector<NetworkEntityId> crew_registry::take_pending_updates()
{
std::vector<NetworkEntityId> pending;
@@ -425,6 +470,8 @@ void post_authority_command(user_command Command, uint32_t Recipient, glm::vec3
// frames to wait before repeating an authority request that has not taken effect yet
static int const ACTION_COOLDOWN_FRAMES = 30;
// how many times to ask a vehicle's AI driver to step aside before giving up on it
static int const AI_HANDOVER_ATTEMPTS = 5;
void crew_registry::reconcile()
{
@@ -457,10 +504,26 @@ void crew_registry::reconcile()
if (dynamic->Mechanik != nullptr && dynamic->Mechanik->AIControllFlag)
{
// first human on board takes over from the AI
WriteLog("net: " + dynamic->name() + " taken over from the AI driver", logtype::net);
post_authority_command(user_command::aidriverdisable, (uint32_t)command_target::vehicle | train->id(), dynamic->GetPosition(), std::string());
vehicle.action_cooldown = ACTION_COOLDOWN_FRAMES;
if (vehicle.ai_attempts < AI_HANDOVER_ATTEMPTS)
{
// first human on board takes over from the AI
if (vehicle.ai_attempts == 0)
WriteLog("net: " + dynamic->name() + " taken over from the AI driver", logtype::net);
++vehicle.ai_attempts;
post_authority_command(user_command::aidriverdisable, (uint32_t)command_target::vehicle | train->id(), dynamic->GetPosition(), std::string());
vehicle.action_cooldown = ACTION_COOLDOWN_FRAMES;
}
else if (vehicle.ai_attempts == AI_HANDOVER_ATTEMPTS)
{
// asking again would only fill the log; say so once and leave it
++vehicle.ai_attempts;
ErrorLog("net: " + dynamic->name() + " will not let go of its AI driver", logtype::net);
}
}
else
{
vehicle.ai_attempts = 0;
}
continue;
}