public void OnEnable() { logDispatcher = GetComponent <SpatialOSComponent>().Worker.LogDispatcher; cubeSpawnerCommandRequestHandler.OnDeleteSpawnedCubeRequest += OnDeleteSpawnedCubeRequest; worldCommandResponseHandler.OnDeleteEntityResponse += OnDeleteEntityResponse; }
public IInjectable CreateInjectable(Entity entity, EntityManager entityManager, ILogDispatcher logDispatcher) { return(new CommandRequestHandler(entity, entityManager, logDispatcher)); }
public ReaderWriterImpl(Entity entity, EntityManager entityManager, ILogDispatcher logDispatcher) : base(entity, entityManager, logDispatcher) { }
public CommandResponseHandler(Entity entity, EntityManager entityManager, ILogDispatcher logger) : base(logger) { this.entity = entity; this.entityManager = entityManager; this.logger = logger; }
public CommandRequestSender(Entity entity, EntityManager entityManager, ILogDispatcher logger) : base(logger) { this.entity = entity; this.entityManager = entityManager; this.logger = logger; }
protected ReaderWriterBase(Entity entity, EntityManager entityManager, ILogDispatcher logDispatcher) { Entity = entity; EntityManager = entityManager; this.logDispatcher = logDispatcher; }
public RequiredFieldInjector(EntityManager entityManager, ILogDispatcher logger) { this.logger = logger; this.injectableFactory = new InjectableFactory(entityManager, logger); }
private WorldCommandRequestSender(Entity entity, EntityManager entityManager, ILogDispatcher logDispatcher) : base(logDispatcher) { this.entity = entity; this.entityManager = entityManager; }
/// <summary> /// Asynchronously connects a worker to the SpatialOS runtime. /// </summary> /// <remarks> /// Uses the global position of this GameObject as the worker origin. /// Uses <see cref="ShouldUseLocator"/> to determine whether to connect via the Locator. /// </remarks> /// <param name="workerType">The type of the worker to connect as</param> /// <param name="logger">The logger for the worker to use.</param> /// <returns></returns> public async Task Connect(string workerType, ILogDispatcher logger) { // Check that other workers have finished trying to connect before this one starts. // This prevents races on the workers starting and races on when we start ticking systems. await WorkerConnectionSemaphore.WaitAsync(); try { // A check is needed for the case that play mode is exited before the semaphore was released. if (!Application.isPlaying) { return; } var origin = transform.position; ConnectionDelegate connectionDelegate; var chosenService = GetConnectionService(); var connectionParameters = GetConnectionParameters(workerType, chosenService); switch (chosenService) { case ConnectionService.Receptionist: connectionDelegate = async() => await Worker.CreateWorkerAsync(GetReceptionistConfig(workerType), connectionParameters, logger, origin) .ConfigureAwait(false); break; case ConnectionService.Locator: connectionDelegate = async() => await Worker .CreateWorkerAsync(GetLocatorConfig(), connectionParameters, logger, origin) .ConfigureAwait(false); break; case ConnectionService.AlphaLocator: connectionDelegate = async() => await Worker.CreateWorkerAsync(GetAlphaLocatorConfig(workerType), connectionParameters, logger, origin) .ConfigureAwait(false); break; default: throw new Exception("No valid connection flow type selected"); } Worker = await ConnectWithRetries(connectionDelegate, MaxConnectionAttempts, logger, workerType); Worker.OnDisconnect += OnDisconnected; HandleWorkerConnectionEstablished(); World.Active = World.Active ?? Worker.World; ScriptBehaviourUpdateOrder.UpdatePlayerLoop(World.AllWorlds.ToArray()); } catch (Exception e) { logger.HandleLog(LogType.Error, new LogEvent("Failed to create worker") .WithException(e) .WithField("WorkerType", workerType) .WithField("Message", e.Message)); #if UNITY_EDITOR // Temporary warning to be replaced when we can reliably detect if a local runtime is running, or not. logger.HandleLog(LogType.Warning, new LogEvent( "Is a local runtime running? If not, you can start one from 'SpatialOS -> Local launch' or by pressing Cmd/Ctrl-L") .WithField("Reason", "A worker running in the Editor failed to connect")); #endif // A check is needed for the case that play mode is exited before the connection can complete. if (Application.isPlaying) { HandleWorkerConnectionFailure(e.Message); Dispose(); } } finally { WorkerConnectionSemaphore.Release(); } foreach (var callback in workerConnectedCallbacks) { callback(Worker); } }
public RequirableBase(ILogDispatcher logDispatcher) { this.logDispatcher = logDispatcher; }
public EntityGameObjectLinker(World world, ILogDispatcher logDispatcher) { this.world = world; this.logDispatcher = logDispatcher; }
public GameObjectCreatorFromMetadata(string workerType, Vector3 workerOrigin, ILogDispatcher logger) { this.workerType = workerType; this.workerOrigin = workerOrigin; this.logger = logger; }
public WorkerSystem(IConnectionHandler connectionHandler, Connection connection, ILogDispatcher logDispatcher, string workerType, Vector3 origin) { Connection = connection; LogDispatcher = logDispatcher; WorkerType = workerType; Origin = origin; ConnectionHandler = connectionHandler; MessagesToSend = connectionHandler.GetMessagesToSendContainer(); }
/// <summary> /// Creates a <see cref="Worker"/> object asynchronously. /// </summary> /// <param name="connectionHandlerBuilder"> /// A builder which describes how to create the <see cref="IConnectionHandler"/> for this worker. /// </param> /// <param name="workerType">The type of worker to connect as.</param> /// <param name="logDispatcher">The logger to use for this worker.</param> /// <param name="token">A cancellation token which will cancel this asynchronous operation</param> /// <returns>A task which represents the asynchronous creation of a worker.</returns> public static async Task<Worker> CreateWorkerAsync(IConnectionHandlerBuilder connectionHandlerBuilder, string workerType, ILogDispatcher logDispatcher, CancellationToken? token = null) { var handler = await connectionHandlerBuilder.CreateAsync(token); return new Worker(handler, workerType, logDispatcher); }
public IInjectable CreateInjectable(Entity entity, EntityManager entityManager, ILogDispatcher logDispatcher) { return(new ReaderWriterImpl(entity, entityManager, logDispatcher)); }
protected override void OnCreateManager(int capacity) { base.OnCreateManager(capacity); logDispatcher = World.GetExistingManager <WorkerSystem>().LogDispatcher; }
public void SetDispatcher(ILogDispatcher dispatcher) { }
public IInjectable CreateInjectable(Entity entity, EntityManager entityManager, ILogDispatcher logDispatcher) { return(new WorldCommandResponseHandler(logDispatcher)); }