Luis Gonzalez
86575dd5bc
A remote/cold client added NetworkStreamInGame the instant it got a
NetworkId, before the gameplay subscene's ghost prefabs finished
streaming. The server's first ghost snapshot then hit a client that
couldn't resolve those prefabs -> "ghost ... ENTITY_NOT_FOUND" ->
forced disconnect ("nothing loads"). On loopback / fast LAN the
go-in-game handshake beats the ~0.4s entity-subscene stream. The host
never hit it (it shares the server's loaded subscene); every remote
join did -- MPPM virtual players and real networked clients alike.
GoInGameClientSystem now gates full-client go-in-game on the gameplay
subscene being loaded (HasSingleton<PlayerSpawner>); thin clients skip
the gate. Verified cross-process in a standalone build over loopback:
join ghost-prefab errors 15->0, disconnects 1->0, client stays
connected and resolves all server ghosts.
Also adds a -mhost / -mjoin <ip> command-line hook to MainMenuController
for headless co-op testing (drives WorldLauncher.StartSession, no UI).
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
60 lines
2.9 KiB
C#
60 lines
2.9 KiB
C#
using ProjectM.Simulation;
|
|
using Unity.Burst;
|
|
using Unity.Collections;
|
|
using Unity.Entities;
|
|
using Unity.NetCode;
|
|
|
|
namespace ProjectM.Client
|
|
{
|
|
/// <summary>
|
|
/// Client-side connection handshake: for every connection that has been assigned a
|
|
/// <see cref="NetworkId"/> but is not yet <see cref="NetworkStreamInGame"/>, mark it in-game and
|
|
/// fire a <see cref="GoInGameRequest"/> RPC so the server spawns this client's player ghost.
|
|
/// Adding NetworkStreamInGame is what gates snapshot/command flow on. Mirrors the netcode
|
|
/// "networked-cube" go-in-game sample.
|
|
/// </summary>
|
|
[BurstCompile]
|
|
[WorldSystemFilter(WorldSystemFilterFlags.ClientSimulation | WorldSystemFilterFlags.ThinClientSimulation)]
|
|
public partial struct GoInGameClientSystem : ISystem
|
|
{
|
|
[BurstCompile]
|
|
public void OnCreate(ref SystemState state)
|
|
{
|
|
var builder = new EntityQueryBuilder(Allocator.Temp)
|
|
.WithAll<NetworkId>()
|
|
.WithNone<NetworkStreamInGame>();
|
|
state.RequireForUpdate(state.GetEntityQuery(builder));
|
|
}
|
|
|
|
[BurstCompile]
|
|
public void OnUpdate(ref SystemState state)
|
|
{
|
|
// A FULL client must not go in-game until the gameplay subscene's ghost prefabs have streamed in.
|
|
// Otherwise the server's first ghost snapshot arrives before the client can resolve those prefabs
|
|
// ("ghost ... ENTITY_NOT_FOUND" -> the server disconnects the connection -> "nothing loads"). On
|
|
// loopback / fast LAN the connect+go-in-game handshake easily beats the ~0.5s entity-subscene stream.
|
|
// PlayerSpawner is a subscene-baked singleton that co-loads with the ghost prefabs, so its presence
|
|
// is a sound "subscene ready" gate. Thin clients never instantiate ghosts (and don't stream the
|
|
// subscene), so they skip the gate and connect immediately.
|
|
bool isThinClient = (state.WorldUnmanaged.Flags & WorldFlags.GameThinClient) == WorldFlags.GameThinClient;
|
|
if (!isThinClient && !SystemAPI.HasSingleton<PlayerSpawner>())
|
|
return;
|
|
|
|
var ecb = new EntityCommandBuffer(Allocator.Temp);
|
|
|
|
foreach (var (_, connection) in
|
|
SystemAPI.Query<RefRO<NetworkId>>().WithNone<NetworkStreamInGame>().WithEntityAccess())
|
|
{
|
|
ecb.AddComponent<NetworkStreamInGame>(connection);
|
|
|
|
byte classId = SystemAPI.HasSingleton<ClassSelection>() ? SystemAPI.GetSingleton<ClassSelection>().ClassId : (byte)0;
|
|
var request = ecb.CreateEntity();
|
|
ecb.AddComponent(request, new GoInGameRequest { ClassId = classId }); // Slice 2: carry the chosen class
|
|
ecb.AddComponent(request, new SendRpcCommandRequest { TargetConnection = connection });
|
|
}
|
|
|
|
ecb.Playback(state.EntityManager);
|
|
}
|
|
}
|
|
}
|