Exemplo n.º 1
0
        private void ExecuteSong(NoteQuality hitNoteQuality, float beatTimeDiff, Song matchingSong)
        {
            NoteHit?.Invoke(hitNoteQuality, beatTimeDiff);
            if (_beatInputHandler == Constants.Noop)
            {
                // don't execute song if game has been finished with the last note
                return;
            }
            _streakScore += _currentQualities.Aggregate(0, (total, curQuality) => total + (int)curQuality);
            _streakPower  = Mathf.Min(_streakScore / Constants.REQUIRED_STREAK_SCORE, Constants.MAX_STREAK_POWER);
            _currentSong  = matchingSong;
            int curStreakPower = _streakPower;

            _currentSong.ExecuteCommand(hitNoteQuality, curStreakPower);
            _coroutineProvider.StartCoroutine(Coroutines.ExecuteAfterSeconds(HALF_NOTE_TIME, () => {
                ExecutionStarted?.Invoke(matchingSong, curStreakPower);
                DisableTouchHandler();
            }));
            ExecutionStarting?.Invoke(_currentSong, curStreakPower);
            _currentCommandUpdate = _currentSong.ExecuteCommandUpdate;
            ResetBeatAfterSeconds(NOTE_TIME * 4);
        }
        internal async Task StartSubscribe()
        {
            var reader = TaskQueueReader;

            SubscriberStarted?.Invoke(this);
            while (true)
            {
                T newPayload;
                try
                {
                    newPayload = await reader.ReadAsync(TaskManagerCancellationToken.Token).ConfigureAwait(false);
                }
                catch (OperationCanceledException)
                {
                    break;
                }
                catch (Exception e)
                {
                    TaskPayloadFetchException?.Invoke(this, e);
                    continue;
                }

                var cts = TaskManagerCancellationToken;
                CancellationTokenSource localCts = null;
                var timeout = ExecutionTimeout;
                if (timeout.HasValue)
                {
                    localCts = new CancellationTokenSource(timeout.Value);
                    cts      = CancellationTokenSource.CreateLinkedTokenSource(
                        TaskManagerCancellationToken.Token,
                        localCts.Token);
                }
                try
                {
                    ExecutionStarting?.Invoke(this);
                    await Execution(newPayload, cts).ConfigureAwait(false);

                    ExecutionFinished?.Invoke(this);
                }
                catch (OperationCanceledException ex)
                {
                    if (localCts?.IsCancellationRequested ?? false)
                    {
                        ExecutionTimeoutEvent?.Invoke(this);
                    }
                    else
                    {
                        SubscriberCancelled?.Invoke(this, ex);
                        break;
                    }
                }
                catch (ObjectDisposedException ed)
                {
                    SubscriberCancelled?.Invoke(this, ed);
                    break;
                }
                catch (Exception e)
                {
                    ExecutionException?.Invoke(this, e);
                }

                if (TaskManagerCancellationToken.IsCancellationRequested)
                {
                    break;
                }
            }
            TaskSubscriberFinalized?.Invoke(this);
        }
Exemplo n.º 3
0
        internal async Task PullTaskAsync(CancellationToken token)
        {
            var alreadyLogout = false;

            TaskPullerStarted?.Invoke(this);
            while (true)
            {
                if (TaskManagerCancellationToken.IsCancellationRequested)
                {
                    break;
                }

                if (!LinkedMetadata.IsExecutorEnabled)
                {
                    break;
                }

                var cts = TaskManagerCancellationToken;
                CancellationTokenSource localCts = null;
                var timeout = ExecutionTimeout;
                if (timeout.HasValue)
                {
                    localCts = new CancellationTokenSource(timeout.Value);
                    cts      = CancellationTokenSource.CreateLinkedTokenSource(
                        TaskManagerCancellationToken.Token,
                        localCts.Token);
                }

                try
                {
                    ExecutionStarting?.Invoke(this);
                    await Execution(cts).ConfigureAwait(false);

                    ExecutionFinished?.Invoke(this);
                }
                catch (OperationCanceledException)
                {
                    if (localCts?.IsCancellationRequested ?? false)
                    {
                        ExecutionTimeoutEvent?.Invoke(this);
                    }
                    else
                    {
                        ExecutionCancelled?.Invoke(this);
                        break;
                    }
                }
                catch (ObjectDisposedException)
                {
                    break;
                }
                catch (Exception e)
                {
                    ExecutionExceptionHandler?.Invoke(this, e);
                }

                if (TaskManagerCancellationToken.IsCancellationRequested)
                {
                    break;
                }

                if (!LinkedMetadata.IsExecutorEnabled)
                {
                    break;
                }

                if (LinkedMetadata.GlobalApproveNewExecutorCreationCriteriaInContext() && ShouldTryToCreateNewPuller())
                {
                    CreatingNewPuller?.Invoke(this);
#pragma warning disable 4014
                    LinkedMetadata.CreateNewTaskExecutor(token);
#pragma warning restore 4014
                    NewPullerCreated?.Invoke(this);
                }

                if (!ShouldTryTerminateCurrentPuller())
                {
                    continue;
                }

                //Try kill itself
                if (await LinkedMetadata.TryPerformLogoutAsync().ConfigureAwait(false))
                {
                    alreadyLogout = true;
                    break;
                }
            }

            if (!alreadyLogout)
            {
                await LinkedMetadata.ForceLogoutAsync().ConfigureAwait(false);
            }

            TaskPullerFinalized?.Invoke(this);
        }