public LidgrenPunchThroughFacilitator(LidgrenNetworkTransporter transporter,
ICoroutineScheduler coroutineScheduler, LidgrenNatPunchClient natPunchClient, float connectionAttemptTimeout,
ConnectionIdPool connectionIdPool)
{
_connectionIdPool = connectionIdPool;
_connectionRegistrationPool = new ObjectPool <ConnectionRegistration>(() => new ConnectionRegistration());
_punchAttempts = new Dictionary <NatPunchId, IPooledObject <ConnectionRegistration> >();
_connectionAttempts = new ArrayDictionary <ConnectionId, IPooledObject <ConnectionRegistration> >(
connectionIdPool.MaxConnectionIds);
_activeConnections = new ArrayDictionary <ConnectionId, IPooledObject <ConnectionRegistration> >(
connectionIdPool.MaxConnectionIds);
_cancelledAttempts = new ConnectionId[_connectionIdPool.MaxConnectionIds];
for (int i = 0; i < _cancelledAttempts.Length; i++)
{
_cancelledAttempts[i] = ConnectionId.NoConnection;
}
_transporter = transporter;
_connectionAttemptTimeout = connectionAttemptTimeout;
_connectionIdPool = connectionIdPool;
_natPunchClient = natPunchClient;
_transporter.RequestApproval += PassRequestApproval;
_transporter.OnConnectionOpened += OnConnectionOpened;
_transporter.OnConnectionClosed += OnConnectionClosed;
_cleanupRoutine = coroutineScheduler.Run(PunchTimeoutCleanup());
}
public ActiveNetwork(NetworkSystems networkSystems, VoloNetworkServer networkServer, VoloNetworkClient networkClient,
ICoroutineScheduler coroutineScheduler)
{
NetworkSystems = networkSystems;
_networkServer = networkServer;
_networkClient = networkClient;
_coroutineScheduler = coroutineScheduler;
_authorityConnectionId = ConnectionId.NoConnection;
_isSingleplayer = true;
}
public StateMachine(T owner, ICoroutineScheduler scheduler)
{
_owner = owner;
_scheduler = scheduler;
_states = new Dictionary <StateId, StateInstance>();
_stack = new IteratableStack <StateInstance>();
Type type = typeof(T);
_ownerEvents = GetStateEvents(type);
AssertStateMethodIntegrity(type, _ownerEvents);
}
internal void SignalStarted(ICoroutineScheduler scheduler, IExecutionState executionState, Coroutine spawner)
{
lock (SyncRoot)
{
if (Status != CoroutineStatus.WaitingForStart)
{
throw new CoroutineException("Signalling start to non-stated coroutine");
}
Scheduler = scheduler;
ExecutionState = executionState;
Spawner = spawner;
Status = CoroutineStatus.Running;
}
}
public LidgrenNatPunchClient(ICoroutineScheduler coroutineScheduler, LidgrenNatFacilitatorConnection facilitatorConnection,
IConnectionlessTransporter transporter)
{
_tempBuffer = new NetBuffer();
_transporter = transporter;
_facilitatorConnection = facilitatorConnection;
_natPunchAttempts = new Dictionary <NatPunchId, PunchAttempt>();
_natPunchRegistrations = new List <PunchAttempt>();
// _natPunchSessionCache = new RamjetCache<IPEndPoint, IPEndPoint>(
// expireAfterAccess: _punchSessionCacheTimeout, expireAfterWrite: null);
_facilitatorConnection.OnNatPunchSuccess += OnNatPunchSuccess;
_facilitatorConnection.OnNatPunchFailure += OnNatPunchFailure;
_cleanupRoutine = coroutineScheduler.Run(ConnectionTimeoutCleanup());
}
public LidgrenPunchThroughFacilitator(LidgrenNetworkTransporter transporter,
ICoroutineScheduler coroutineScheduler, LidgrenNatPunchClient natPunchClient, float connectionAttemptTimeout)
{
_punchAttempts = new Dictionary <NatPunchId, ConnectionRegistration>();
_connectionAttempts = new Dictionary <ConnectionId, ConnectionRegistration>();
_connectionAttemptRegistrations = new List <ConnectionRegistration>();
_connections = new Dictionary <ConnectionId, ConnectionRegistration>();
_transporter = transporter;
_connectionAttemptTimeout = connectionAttemptTimeout;
_natPunchClient = natPunchClient;
_transporter.OnConnectionOpened += OnConnectionOpened;
_transporter.OnConnectionClosed += OnConnectionClosed;
_cleanupRoutine = coroutineScheduler.Run(ConnectionTimeoutCleanup());
}
public LidgrenNatPunchClient(ICoroutineScheduler coroutineScheduler, LidgrenNatFacilitatorConnection facilitatorConnection)
{
_facilitatorConnection = facilitatorConnection;
_punchAttemptPool = new ObjectPool <PunchAttempt>(() => new PunchAttempt());
{
const int natpunchIdCount = 256;
var punchIds = new NatPunchId[natpunchIdCount];
for (int i = 0; i < natpunchIdCount; i++)
{
punchIds[i] = new NatPunchId(Guid.NewGuid().ToString());
}
_natPunchIds = CollectionUtil.LoopingEnumerator(punchIds);
}
_natPunchAttempts = new Dictionary <NatPunchId, IPooledObject <PunchAttempt> >();
_natPunchRegistrations = new List <IPooledObject <PunchAttempt> >();
_facilitatorConnection.OnNatPunchSuccess += OnNatPunchSuccess;
_facilitatorConnection.OnNatPunchFailure += OnNatPunchFailure;
_cleanupRoutine = coroutineScheduler.Run(ConnectionTimeoutCleanup());
}
private IStateMachine BuildPlayingStateMachine(
ICoroutineScheduler scheduler,
FlyWingsuit.Data wingsuitData,
ParachuteStates.Data parachuteData,
ParachuteStorage parachuteStorage,
ITypedDataCursor <ParachuteStorageViewState> parachuteStorageViewState,
SpectatorMode.Data spectatorData)
{
var machine = new StateMachine <Playing>(this, scheduler);
machine.AddState(PlayingStates.Initial, new ParachuteStates.InitialState(machine))
.Permit(PlayingStates.FlyingWingsuit)
.PermitChild(PlayingStates.Suspended);
machine.AddState(PlayingStates.FlyingWingsuit, new FlyWingsuit(machine, wingsuitData))
.Permit(PlayingStates.EditingParachute)
.Permit(PlayingStates.FlyingParachute)
.PermitChild(PlayingStates.Suspended)
.PermitChild(PlayingStates.Spectating)
.Permit(PlayingStates.Initial);
machine.AddState(PlayingStates.FlyingParachute, new ParachuteStates.Flying(machine, parachuteData))
.Permit(PlayingStates.EditingParachute)
.Permit(PlayingStates.FlyingWingsuit)
.PermitChild(PlayingStates.Spectating)
.PermitChild(PlayingStates.Suspended)
.Permit(PlayingStates.Initial);
machine.AddState(PlayingStates.Spectating, new SpectatorMode(machine, spectatorData))
.PermitChild(PlayingStates.Suspended);
machine.AddState(PlayingStates.EditingParachute, new ParachuteStates.Editing(machine, parachuteData, parachuteStorage, parachuteStorageViewState))
.Permit(PlayingStates.FlyingParachute)
.PermitChild(PlayingStates.Suspended)
.Permit(PlayingStates.Initial);
machine.AddState(PlayingStates.Suspended, new ParachuteStates.InitialState(machine))
.Permit(PlayingStates.Initial);
return(machine);
}
public DefaultCoroutine(ICoroutineScheduler coroutineScheduler)
{
_coroutineScheduler = coroutineScheduler;
}
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 RamnetBase(
ICoroutineScheduler coroutineScheduler,
LidgrenNetworkTransporter transporter,
IPEndPoint natFacilitatorEndpoint,
IMessageSender messageSender,
IDictionary <ObjectType, GameObject> prefabs,
DependencyContainer dependencyContainer)
{
_messageSender = messageSender;
_transporter = transporter;
ILatencyInfo latencyInfo = _transporter;
var networkMessageTypes = MessageExtensions.GenerateNetworkIds(MessageExtensions.GetNetworkMessageTypes(Assembly.GetExecutingAssembly()));
var objectMessageTypes = MessageExtensions.GenerateNetworkIds(MessageExtensions.GetObjectMessageTypes(Assembly.GetExecutingAssembly()));
_messagePool = new MessagePool(MessageExtensions.CreateMessagePools(networkMessageTypes));
var objectMessagePools = MessageExtensions.CreateMessagePools(objectMessageTypes);
var routerConfig = new TransportRouterConfig(
new KeyValuePair <TransportGroupId, TransportGroupConfig>(NetworkGroup.Default,
new TransportGroupConfig(32)));
_natFacilitatorConnection = new LidgrenNatFacilitatorConnection(natFacilitatorEndpoint, _transporter);
_natPunchClient = new LidgrenNatPunchClient(coroutineScheduler, _natFacilitatorConnection, transporter);
_connectionManager = new LidgrenPunchThroughFacilitator(
_transporter,
coroutineScheduler,
connectionAttemptTimeout: 10f,
natPunchClient: _natPunchClient);
_groupRouter = new TransportGroupRouter(_transporter, routerConfig);
Func <ObjectMessageRouter> objectMessageDispatcherFactory =
() => new ObjectMessageRouter(latencyInfo, objectMessageTypes);
var networkMessagePool = new BasicObjectPool <ReplicatedObjectStore.ObjectMessageSender.MulticastNetworkMessage>(
pool => new ReplicatedObjectStore.ObjectMessageSender.MulticastNetworkMessage(pool, networkMessageTypes[typeof(BasicMessage.ToObject)]));
var messageSenderFactory = ReplicatedObjectStore.ObjectMessageSender.CreateFactory(
messageSender,
_groupRouter,
NetworkGroup.Default,
networkMessagePool);
var objectDependencies = new List <object>();
objectDependencies.Add(latencyInfo);
foreach (var pool in objectMessagePools)
{
objectDependencies.Add(pool.Value);
}
var replicationDecorator = ReplicatedObjectStore.GameObjectReplicationDecorator(objectMessageDispatcherFactory,
messageSenderFactory,
objectDependencies,
objectMessageTypes);
var gameObjectFactories = new Dictionary <ObjectType, Func <GameObject> >();
foreach (var kvPair in prefabs)
{
var objectType = kvPair.Key;
var prefab = kvPair.Value;
gameObjectFactories[objectType] = () => {
var instance = GameObject.Instantiate(prefab);
// TODO Copy dependencies into global object dependency container
DependencyInjection.Inject(instance, dependencyContainer);
return(instance);
};
}
int replicatedObjectCapacity = 256;
var objectMessageParser = new ObjectMessageParser(objectMessageTypes);
_replicatedObjectStore = new ReplicatedObjectStore(objectMessageParser, gameObjectFactories, replicationDecorator, replicatedObjectCapacity);
_messageRouter = new MessageRouter(networkMessageTypes);
_groupRouter.SetDataHandler(NetworkGroup.Default, _messageRouter);
_connectionlessMessageSender = new ConnectionlessMessageSender(_transporter);
_preExistingObjects = RamjetAnvil.RamNet.PreExistingObjects.FindAll();
}
public CoroutineEngineHook(ICoroutineScheduler coroutineScheduler)
{
_coroutineScheduler = coroutineScheduler;
}
