public IActorTask[] GetActorTasks(IActor actor)
        {
            if (actor != CurrentActor)
            {
                return(new IActorTask[0]);
            }

            var currentTaskIsComplete = _currentTask?.IsComplete;

            if (currentTaskIsComplete != null && !currentTaskIsComplete.Value && _currentIntention == null)
            {
                return(new[] { _currentTask });
            }

            if (CurrentActor == null)
            {
                throw new InvalidOperationException("Не выбран текущий ключевой актёр.");
            }

            if (_currentIntention == null)
            {
                return(new IActorTask[0]);
            }

            _currentTask      = _currentIntention.CreateActorTask(_currentTask, CurrentActor);
            _currentIntention = null;

            if (_currentTask != null)
            {
                return(new[] { _currentTask });
            }

            return(new IActorTask[0]);
        }
 public void ProcessTaskExecuted(IActorTask actorTask)
 {
     // Этот метод был введен для HumanActorTaskSource.
     // Нужен для того, чтобы сразу начать выполнение следующего действия, не дожидаясь окончания текущего.
     // Например, при использовании парного оружия.
     // Механика пока не реализована.
 }
 /// <inheritdoc />
 public void ProcessTaskExecuted(IActorTask actorTask)
 {
     // Пока ничего не делаем.
     // Это задел для парного оружия.
     // Парное оружие будет позволять выполнять удар вторым оружием,
     // когда задача выполнена, но не закончена.
 }
Exemple #4
0
        public TaskState(IActor actor, IActorTask task, IActorTaskSource taskSource)
        {
            Actor      = actor ?? throw new ArgumentNullException(nameof(actor));
            Task       = task ?? throw new ArgumentNullException(nameof(task));
            TaskSource = taskSource ?? throw new ArgumentNullException(nameof(taskSource));

            Counter         = Task.Cost;
            _valueToExecute = Task.Cost / 2;
        }
        private static void CreateLogicState(out ILogicState logicState, out IActorTask actorTask)
        {
            var startLogicStateMock = new Mock <ILogicState>();
            var startActorTaskMock  = new Mock <IActorTask>();

            actorTask = startActorTaskMock.Object;
            startLogicStateMock.Setup(x => x.GetTask(It.IsAny <IActor>(), It.IsAny <ILogicStrategyData>()))
            .Returns(actorTask);
            logicState = startLogicStateMock.Object;
        }
        public IActorTask CreateActorTask([CanBeNull] IActorTask currentTask, [NotNull] IActor actor)
        {
            var currentMoveTask = currentTask as MoveTask;

            if (currentMoveTask == null)
            {
                return(CreateTaskInner(actor));
            }

            if (currentMoveTask.TargetNode == TargetNode)
            {
                return(currentMoveTask);
            }

            return(CreateTaskInner(actor));
        }
        public void CancelTask(IActorTask cancelledActorTask)
        {
            switch (CurrentControl)
            {
            case ActorTaskSourceControl.Human:
                _humanActorTaskSource.CancelTask(cancelledActorTask);
                break;

            case ActorTaskSourceControl.Bot:
                _botActorTaskContext.CancelTask(cancelledActorTask);
                break;

            case ActorTaskSourceControl.Undefined:
                throw new ActorTaskSourceException("Task source is undefined.");

            default:
                throw new ActorTaskSourceException($"Task source {CurrentControl} is unknown.");
            }
        }
        public void ProcessTaskExecuted(IActorTask actorTask)
        {
            switch (CurrentControl)
            {
            case ActorTaskSourceControl.Human:
                _humanActorTaskSource.ProcessTaskExecuted(actorTask);
                break;

            case ActorTaskSourceControl.Bot:
                _botActorTaskContext.ProcessTaskExecuted(actorTask);
                break;

            case ActorTaskSourceControl.Undefined:
                throw new ActorTaskSourceException("Task source is undefined.");

            default:
                throw new ActorTaskSourceException($"Task source {CurrentControl} is unknown.");
            }
        }
 public PreFundingSFOrchestrationService(
     IJsonSerializationService jsonSerializationService,
     IIlrFileProviderService ilrFileProviderService,
     IFundingServiceDto fundingServiceDto,
     IPopulationService populationService,
     IActorTask <IALBActor, ALBGlobal> albActorTask,
     IActorTask <IFM81Actor, FM81Global> fm81ActorTask,
     IActorTask <IFM70Actor, FM70Global> fm70ActorTask,
     IActorTask <IFM35Actor, FM35Global> fm35ActorTask,
     IActorTask <IFM36Actor, FM36Global> fm36ActorTask,
     IActorTask <IFM25Actor, FM25Global> fm25ActorTask,
     IKeyValuePersistenceService keyValuePersistenceService,
     IPagingService <ILearner> learnerPagingService,
     IExternalDataCache externalDataCache,
     IInternalDataCache internalDataCache,
     IFileDataCache fileDataCache,
     ITopicAndTaskSectionConfig topicAndTaskSectionConfig,
     ILogger logger)
 {
     _jsonSerializationService   = jsonSerializationService;
     _ilrFileProviderService     = ilrFileProviderService;
     _fundingServiceDto          = fundingServiceDto;
     _populationService          = populationService;
     _albActorTask               = albActorTask;
     _fm81ActorTask              = fm81ActorTask;
     _fm70ActorTask              = fm70ActorTask;
     _fm35ActorTask              = fm35ActorTask;
     _fm36ActorTask              = fm36ActorTask;
     _fm25ActorTask              = fm25ActorTask;
     _keyValuePersistenceService = keyValuePersistenceService;
     _externalDataCache          = externalDataCache;
     _internalDataCache          = internalDataCache;
     _fileDataCache              = fileDataCache;
     _learnerPagingService       = learnerPagingService;
     _topicAndTaskSectionConfig  = topicAndTaskSectionConfig;
     _logger = logger;
 }
 public void ProcessTaskComplete(IActorTask actorTask)
 {
     // Этот метод был введен для HumanActorTaskSource.
     // В этой реализации источника команд не используется.
 }
 public void CancelTask(IActorTask cencelledActorTask)
 {
     // Этот метод был введен для HumanActorTaskSource.
     // В этой реализации источника команд не используется.
 }
 /// <inheritdoc />
 public void CancelTask(IActorTask cancelledActorTask)
 {
     _intentionWait         = false;
     _currentActorIntention = null;
     DropIntentionWaiting();
 }
 /// <inheritdoc />
 public void ProcessTaskComplete(IActorTask actorTask)
 {
     _intentionWait         = false;
     _currentActorIntention = null;
 }
 public void ProcessTaskComplete(IActorTask actorTask)
 {
     _intentionWait = false;
 }
Exemple #15
0
        public IActorTask CreateActorTask(IActorTask currentTask, IActor actor)
        {
            var task = TaskFactory(actor);

            return(task);
        }