This component manages the game's networking state, including server creation, map loading, and player spawning. It handles the lifecycle of map instances and synchronizes player sessions across the network.
using System;
using System.Linq;
using System.Reflection;
using System.Security.Cryptography.X509Certificates;
using System.Threading.Tasks;
using Sandbox.Mapping;
namespace Sandbox;
public sealed partial class NetworkManager : Component, Component.INetworkListener
{
public static NetworkManager Instance { get; private set; }
public readonly List<PlayerSession> PlayerSessions = [];
[Property] public GameObject PlayerPrefab { get; set; }
[Property] GameObject VRHandsPrefab { get; set; }
/// <summary>
/// Create a server (if we're not joining one)
/// </summary>
[Property] public bool StartServer { get; set; } = true;
/// <summary>When true, VR clients skip the height calibration screen and spawn with the default eye height.</summary>
[Property] public bool SkipHeightCalibration { get; set; }
/// <summary>When true, the host will pick a random map from the map pool if no map is specified.</summary>
[Property] public bool PickRandomMapOnEmptyMapName { get; set; } = true;
[Sync, Change( nameof( OnMapChange ) )] public string MapName { get; private set; } = LaunchArguments.Map;
private MapInstance _mapInstance;
private GameObject _loadingScreenGo;
private MapLoadingScreen _loadingScreen;
private bool _showMapLoadingScreen = false;
private float _nextPlayerSpawnCheck;
/// <summary>True when the map is loaded, or no map was requested.</summary>
public bool IsMapReady =>
string.IsNullOrEmpty( MapName )
|| ( _mapInstance is not null && _mapInstance.IsLoaded );
protected override void OnStart()
{
Instance = this;
if ( string.IsNullOrEmpty( MapName ) && Networking.IsHost && PickRandomMapOnEmptyMapName )
{
var randomMap = PickRandomMap();
if ( !string.IsNullOrEmpty( randomMap ) )
MapName = randomMap;
}
if ( _mapInstance is null )
CreateMapInstance( MapName );
Log.Info( $"Map name: {MapName}" );
if ( Game.IsRunningInVR )
{
VRHandsPrefab.Clone( new Transform( Vector3.Zero, Rotation.Identity ) );
}
}
protected override void OnUpdate()
{
UpdateMapLoadingScreen();
UpdateBots();
UpdatePlayerSpawns();
}
private void UpdatePlayerSpawns()
{
if ( !Networking.IsHost || !IsMapReady || Time.Now < _nextPlayerSpawnCheck )
return;
_nextPlayerSpawnCheck = Time.Now + 0.5f;
// The host can become ready before the map finishes loading. Readiness
// callbacks and map-loaded callbacks are wakeups, not the only chance to
// spawn. The shared gate also keeps existing (including dead) pawns intact.
foreach ( var session in PlayerSessions.ToArray() )
TrySpawnPlayer( session );
}
protected override void OnDestroy()
{
DestroyBotPawns();
DestroyMapInstance();
if ( _loadingScreenGo.IsValid() )
_loadingScreenGo.Destroy();
if ( Instance == this )
Instance = null;
}
private void UpdateMapLoadingScreen()
{
EnsureMapLoadingScreen();
if ( _showMapLoadingScreen )
{
if ( _loadingScreenGo.IsValid() )
{
_loadingScreenGo.Enabled = true;
_loadingScreen.Show( MapName );
}
}
else
{
_loadingScreenGo?.Enabled = false;
}
}
private string PickRandomMap()
{
var deathmatch = DeathmatchGame.Instance ?? Scene.GetAll<DeathmatchGame>().FirstOrDefault();
var pool = (deathmatch?.MapPool ?? [])
.Where( m => !string.IsNullOrWhiteSpace( m ) )
.Select( m => m.Trim() )
.Distinct( StringComparer.OrdinalIgnoreCase )
.ToList();
if ( pool.Count == 0 )
{
Log.Warning( "Host has no MapName and the map pool is empty" );
return null;
}
return pool[Game.Random.Int( 0, pool.Count - 1 )];
}
private void CreateMapInstance( string mapName )
{
var mapGO = new GameObject( "Map" );
mapGO.NetworkMode = NetworkMode.Never;
_mapInstance = mapGO.AddComponent<MapInstance>( startEnabled: false );
_mapInstance.OnMapLoaded += OnMapLoaded;
_mapInstance.OnMapUnloaded += OnMapUnloaded;
_mapInstance.Enabled = true;
_mapInstance.MapName = mapName;
}
private void DestroyMapInstance()
{
if ( _mapInstance is null )
return;
_mapInstance.OnMapLoaded -= OnMapLoaded;
_mapInstance.OnMapUnloaded -= OnMapUnloaded;
if ( _mapInstance.GameObject.IsValid() )
_mapInstance.GameObject.Destroy();
_mapInstance = null;
}
protected override async Task OnLoad()
{
if ( Scene.IsEditor )
return;
if ( StartServer && !Networking.IsActive )
{
LoadingScreen.Title = "Creating Lobby";
await Task.DelayRealtimeSeconds( 0.1f );
Networking.CreateLobby( new() );
}
}
public void OnActive( Connection channel )
{
AddPlayerSession( channel );
TrySpawnPlayer( channel );
}
private void AddPlayerSession( Connection channel )
{
var sessionGO = new GameObject( $"PlayerSession_{channel.Id}" );
sessionGO.AddComponent<PlayerSession>();
sessionGO.NetworkSpawn( channel );
}
public void RespawnPlayer( Connection channel )
{
if ( channel is not null )
RespawnPlayer( GetPlayerSession( channel.Id ) );
}
public void RespawnPlayer( PlayerSession session )
{
if ( !Networking.IsHost || !CanSpawn( session ) )
return;
var player = Scene.GetAll<Player>().FirstOrDefault( p => p.SessionId == session.SessionId );
player?.GameObject.Destroy();
if ( IsMapReady )
SpawnPlayer( session );
}
public void RespawnAllPlayers()
{
if ( !Networking.IsHost )
return;
foreach ( var session in PlayerSessions )
{
if ( session.IsBot )
session.ClearStats();
RespawnPlayer( session );
}
}
/// <summary>Spawns the connection's pawn when map and calibration/ready gates pass.</summary>
public void TrySpawnPlayer( Connection channel )
{
if ( channel is not null )
TrySpawnPlayer( GetPlayerSession( channel.Id ) );
}
/// <summary>Shared spawn gate for human and bot sessions.</summary>
public void TrySpawnPlayer( PlayerSession session )
{
if ( !Networking.IsHost || !IsMapReady || !CanSpawn( session ) )
return;
var existing = Scene.GetAll<Player>().FirstOrDefault( p => p.SessionId == session.SessionId );
if ( existing.IsValid() )
return;
SpawnPlayer( session );
}
private static bool CanSpawn( PlayerSession session ) =>
session.IsValid() && session.IsReadyToSpawn;
private void SpawnPlayer( PlayerSession session )
{
if ( session.IsBot && (!Scene.NavMesh.IsEnabled || Scene.NavMesh.IsGenerating) )
return;
if ( !TryGetSpawnTransform( session, out var spawnTransform ) )
return;
var channel = session.IsBot ? Connection.Host : session.Network.Owner;
if ( channel is null )
return;
var player = PlayerPrefab.Clone( new CloneConfig { Transform = spawnTransform, StartEnabled = false } );
player.GetComponent<Player>( includeDisabled: true ).BotId = session.BotId;
if ( session.IsBot )
{
player.Name = session.DisplayName;
// Disable tracking before activation and the initial network snapshot,
// so every peer receives the bot with its VR hand targets and drivers off.
player.GetComponent<PlayerCharacterController>( includeDisabled: true ).DisableVrHands();
player.AddComponent<BotController>();
}
// Assume that if they have a skinned model renderer, it's the citizen's body
var avatarObject = player.Children.Find( c => c.Name == "Avatar" );
if ( !session.IsBot && avatarObject.IsValid() )
{
var clothing = new ClothingContainer();
clothing.Deserialize( channel.GetUserData( "avatar" ) );
var skinnedModelRenderer = avatarObject.GetComponent<SkinnedModelRenderer>( includeDisabled: true );
if ( skinnedModelRenderer is not null )
{
clothing.Apply( skinnedModelRenderer );
}
}
else if ( session.IsBot )
{
if ( session.Dresser is null )
{
session.Dresser = new Dresser();
session.Dresser.Randomize();
}
var skinnedModelRenderer = avatarObject.GetComponent<SkinnedModelRenderer>( includeDisabled: true );
session.Dresser.BodyTarget = skinnedModelRenderer;
session.Dresser.Apply();
}
player.NetworkSpawn( new NetworkSpawnOptions { Owner = channel, OwnerTransfer = OwnerTransfer.Fixed, StartEnabled = true } );
}
/// <summary>Uses the reserved VR spawn or a random spawn point, without offsets or occupancy checks.</summary>
public bool TryGetSpawnTransform( PlayerSession session, out Transform spawnTransform )
{
if ( session.IsValid() && session.HasReservedSpawn )
{
spawnTransform = new Transform( session.ReservedSpawnPosition, session.ReservedSpawnRotation );
return true;
}
var spawnPoints = Scene.GetAllComponents<SpawnPoint>().ToArray();
if ( spawnPoints.Length == 0 )
{
spawnTransform = global::Transform.Zero;
return false;
}
spawnTransform = spawnPoints[Game.Random.Int( 0, spawnPoints.Length - 1 )].Transform.World;
return true;
}
private void OnMapUnloaded()
{
DestroyBotPawns();
Log.Info( "Map unloaded" );
}
private void OnMapLoaded()
{
Log.Info( "Map loaded" );
_showMapLoadingScreen = false;
if ( Networking.IsHost )
{
TerrorTownDoorCompat.ConvertAll( _mapInstance.GameObject );
var doors = Scene.GetAll<Door>();
foreach ( var door in doors )
{
door.GameObject.NetworkSpawn();
}
Scene.NavMesh.Generate( Scene.PhysicsWorld );
Scene.NavMesh.IsEnabled = true;
DeathmatchGame.Instance.StartMatch();
}
}
private void OnMapChange( string oldValue, string newValue )
{
DestroyBotPawns();
Log.Info( $"Changing map to {newValue}. {MapName}" );
DestroyMapInstance();
_showMapLoadingScreen = true;
CreateMapInstance( newValue );
var session = GetPlayerSession( Connection.Local.Id );
session?.ClearStats();
}
private void EnsureMapLoadingScreen()
{
if ( _loadingScreenGo.IsValid() )
return;
if ( Game.IsRunningInVR )
{
if ( VrmapLoadingWorldPanel.Instance is not null )
{
_loadingScreenGo = VrmapLoadingWorldPanel.Instance.GameObject;
_loadingScreen = VrmapLoadingWorldPanel.Instance.MapLoadingScreen;
}
return;
}
_loadingScreenGo = new GameObject( true, "MapLoadingScreen" )
{
NetworkMode = NetworkMode.Never
};
var cameraGo = new GameObject( _loadingScreenGo, true, "MapLoadingCamera" )
{
NetworkMode = NetworkMode.Never
};
var camera = cameraGo.AddComponent<CameraComponent>();
camera.IsMainCamera = true;
camera.ZNear = 1;
camera.FieldOfView = 90;
var screenPanel = _loadingScreenGo.AddComponent<ScreenPanel>();
screenPanel.ZIndex = 1000;
_loadingScreen = _loadingScreenGo.AddComponent<MapLoadingScreen>();
}
public PlayerSession GetPlayerSession( Guid ConnectionId )
{
return PlayerSessions.FirstOrDefault( ps => ps.IsValid() && ps.SessionId == ConnectionId );
}
/// <summary>Fetches the map package and syncs <see cref="MapName"/> so every peer loads it.</summary>
public async Task<bool> SetMap( string map )
{
if ( string.IsNullOrWhiteSpace( map ) )
return false;
var mapPackage = await Package.FetchAsync( map, false );
if ( mapPackage is null )
{
Log.Error( $"Map {map} not found" );
return false;
}
Log.Info( $"Setting map to {map}" );
MapName = map;
return true;
}
[ConCmd( "map", ConVarFlags.Server )]
public static async Task SetMapCommand( Connection caller, string map )
{
if ( !caller.IsHost )
return;
await Instance.SetMap( map );
}
[ConCmd( "maps" )]
public static void ShowMapsCommand()
{
Log.Info( "Available maps:" );
foreach ( var mapName in DeathmatchGame.Instance.MapPool )
{
Log.Info( $"- {mapName}" );
}
}
}