private void Players_PlayerLagUpdated(object sender, ServerPlayer e)
{
LatencyInfo info = e.GetTag <LatencyInfo>(LatencyInfo.Name);
bool didWarn = false;
if (WarnLag > 0)
{
if (e.Lag.InstantLagTime > WarnLag && e.Lag.AverageLag > WarnLag)
{
info.Warnings++;
didWarn = false;
}
}
if (WarningPacketLoss > 0)
{
if (e.Lag.TotalPacketLoss > WarningPacketLoss)
{
if (e.Lag.TotalPacketLoss > info.LastPacketLoss)
{
info.Warnings++;
didWarn = false;
}
info.LastPacketLoss = e.Lag.TotalPacketLoss;
}
}
if (info.Warnings >= MaxWarnings)
{
State.Chat.SendChatToUser(null, e, Resources.KickMessage, false);
e.FlushTCP();
e.Disconnect();
}
else if (didWarn)
{
State.Chat.SendChatToUser(null, e, Resources.WarnMessage, false);
}
}
public void StartMachine(ICoroutineScheduler scheduler, DependencyContainer globalDependencies)
{
#region Networking
var gameSettings = _gameSettingsProvider.ActiveSettings;
var networking = GameObject.Find("Networking");
var lidgrenTransporter = networking.GetComponentInChildren <LidgrenNetworkTransporter>();
var networkMessageSender = networking.GetComponentInChildren <QueueingMessageSender>();
networkMessageSender.Transporter = lidgrenTransporter;
var connectionIdPool = new ConnectionIdPool(maxConnectionIds: 64);
//var connectionManager = new DefaultConnectionManager(lidgrenTransporter, connectionIdPool);
var natFacilitatorEndpoint = Ipv4Endpoint.Parse(gameSettings.Other.NatFacilitatorEndpoint).ToIpEndPoint();
var natFacilitatorConnection = new LidgrenNatFacilitatorConnection(natFacilitatorEndpoint, lidgrenTransporter);
var natPunchClient = new LidgrenNatPunchClient(scheduler, natFacilitatorConnection);
var connectionAttemptTimeout = gameSettings.Other.ConnectionAttemptTimeout;
var natPunchConnectionManager = new LidgrenPunchThroughFacilitator(lidgrenTransporter, scheduler, natPunchClient,
connectionAttemptTimeout, connectionIdPool);
lidgrenTransporter.ConnectionIdPool = connectionIdPool;
var latencyInfo = new LatencyInfo(connectionIdPool.MaxConnectionIds);
var groupRouterConfig = ConnectionGroups.RouterConfig;
var networkSystems = NetworkSystem.Create(
lidgrenTransporter,
lidgrenTransporter,
groupRouterConfig,
ConnectionGroups.Default,
ReplicationObjects.Factories,
networkMessageSender,
natPunchConnectionManager,
latencyInfo,
globalDependencies);
var voloServer = networking.GetComponentInChildren <VoloNetworkServer>();
voloServer.NetworkSystems = networkSystems;
voloServer.NatFacilitatorConnection = natFacilitatorConnection;
var voloClient = networking.GetComponentInChildren <VoloNetworkClient>();
voloClient.NetworkSystems = networkSystems;
voloClient.LatencyInfo = latencyInfo;
var activeNetwork = new ActiveNetwork(networkSystems, voloServer, voloClient, scheduler);
_playingData.ActiveNetwork = activeNetwork;
_mainMenuData.ActiveNetwork = activeNetwork;
_serverBrowserData.ActiveNetwork = activeNetwork;
/*
* Create lean and mean main menu system that allows a player to choose between single and multiplayer
*
* Notes:
* - Keep as much logic that is generic to both single and multiplayer generic. Don't make a special code path
* for singleplayer unless it is a feature that is only available in singleplayer.
* - Options menu should be as game independent as possible, not relying on a specific singleplayer state for example.
* - State machine transitions should also become separate states such that we can handle them in a better, cleaner way
*
*
* Case 1: Single player game
* - Boot game, start singleplayer, fly for one round, quit game
* - On boot: create instance of a network system
* - Pass network system into the state machine
* - When going into the playing state, spawn/despawn/respawn pilot through replicator
*
* Case 2: Multiplayer game - server
* - Boot game, main screen: choose to create multiplayer server,
* - on boot create instance of network system
* - when in starting multiplayer server state open transporter
* - when a spawnpoint is selected replicate the player
* - separate state machine for multiplayer logic
*
* Case 3: Multiplayer game - client
* - Boot game, main screen: choose to join a multiplayer server
* - server list: allow client to join a game, show if join/connect is in progress, allow for cancellation
* - when a spawnpoint is selected request a spawn to the server
*/
#endregion
_machine = new StateMachine <VoloStateMachine>(this, scheduler);
_machine.AddState(States.NewsFlash, new NewsFlash(_machine, _newsFlashData))
.Permit(States.TitleScreen);
_machine.AddState(States.TitleScreen, new TitleScreen(_machine, _titleScreenData))
.PermitChild(States.Frozen)
.Permit(States.MainMenu);
_machine.AddState(States.MainMenu, new MainMenu(_machine, _mainMenuData))
.PermitChild(States.Frozen)
.Permit(States.TitleScreen)
.Permit(States.ServerBrowser)
.Permit(States.SpawnScreen);
_machine.AddState(States.ServerBrowser, new ServerBrowser(_machine, _serverBrowserData))
.PermitChild(States.Frozen)
.Permit(States.MainMenu)
.Permit(States.SpawnScreen);
_machine.AddState(States.SpawnScreen, new SpawnScreen(_machine, _spawnScreenData))
.PermitChild(States.Frozen)
.PermitChild(States.OptionsMenu)
.Permit(States.MainMenu)
.Permit(States.Playing);
_machine.AddState(States.Playing, new Playing(_machine, _playingData, _flyWingsuitData, _flyParachuteData, _spectatorModeData))
.PermitChild(States.Frozen)
.PermitChild(States.OptionsMenu)
.Permit(States.SpawnScreen);
_machine.AddState(States.OptionsMenu, new OptionsMenuState(_machine, _optionsMenuData))
.PermitChild(States.Frozen)
.Permit(States.SpawnScreen)
.Permit(States.MainMenu);
_machine.AddState(States.Frozen, new Frozen(_machine, _frozenData));
_machine.Transition(States.NewsFlash);
}
public PublicFolderActivityPerformanceTracker(SyncActivity trackedActivity, FolderOperationCounter folderOperationCounter, SyncStateCounter syncStateCounter, LatencyInfo mrsProxyLatencyInfo, PerformanceDataProvider transientRetryDelayTracker)
{
ArgumentValidator.ThrowIfNull("folderOperationCounter", folderOperationCounter);
ArgumentValidator.ThrowIfNull("syncStateCounter", syncStateCounter);
ArgumentValidator.ThrowIfNull("mrsProxyLatencyInfo", mrsProxyLatencyInfo);
ArgumentValidator.ThrowIfNull("transientRetryDelayTracker", transientRetryDelayTracker);
this.folderOperationCounter = folderOperationCounter;
this.syncStateCounter = syncStateCounter;
this.transientRetryDelayTracker = transientRetryDelayTracker;
this.trackedActivity = trackedActivity;
this.mrsProxyLatencyInfo = mrsProxyLatencyInfo;
}
