public void Evaluate(ExpressionInfo expression, ITaskEngine taskEngine, Action <object> callback) { IEnumerator enumerator; if (expression.Value is TaskInputInfo) { TaskInputInfo input = (TaskInputInfo)expression.Value; enumerator = (IEnumerator)taskEngine.Memory.ReadOutput(input.Scope.TaskId, input.OutputTask.TaskId, input.OutputIndex); } else { enumerator = (IEnumerator)expression.Value; } IterationResult result; if (enumerator.MoveNext()) { result = new IterationResult(enumerator.Current, false); } else { enumerator.Reset(); result = new IterationResult(null, true); } callback(result); }
private void OnTick() { for (int i = 0; i < m_taskRunners.Length; ++i) { ITaskRunner taskRunner = m_taskRunners[i]; if (taskRunner != null) { taskRunner.Tick(); } } for (int i = 0; i < m_pathFinders.Length; ++i) { IPathFinder pathFinder = m_pathFinders[i]; if (pathFinder != null) { pathFinder.Tick(); } } for (int i = 0; i < m_taskEngines.Length; ++i) { ITaskEngine taskEngine = m_taskEngines[i]; if (taskEngine != null) { taskEngine.Tick(); } } }
private void SubmitToEngine(int playerIndex, List <Cmd> commandsToSubmit) { if (commandsToSubmit.Count == 1) { ITaskEngine taskEngine = m_engine.GetClientTaskEngine(playerIndex); taskEngine.TerminateAll(); m_engine.Submit(playerIndex, commandsToSubmit[0]); //Render hit; } else if (commandsToSubmit.Count > 1) { CompositeCmd cmd = new CompositeCmd { Commands = commandsToSubmit.ToArray() }; ITaskEngine taskEngine = m_engine.GetClientTaskEngine(playerIndex); taskEngine.TerminateAll(); m_engine.Submit(playerIndex, cmd); } else { Debug.LogWarning("No commands to submit"); } }
public async Task Test_DoWork_NoWorkToBeDone(int workerCount) { Faker faker = new Faker(); ITaskEngine taskEngine = CreateTaskEngine(workerCount); Dictionary <string, long> cyclesCountBefore = await GetAllExecutionCyclesCounts(); await taskEngine.StartAsync(); await Task.Delay(faker.Random.Int(500, 5000)); await taskEngine.StopAync(); Dictionary <string, long> cyclesCountAfter = await GetAllExecutionCyclesCounts(); await AssertTotalTasks(expectedTotal : 0); await AssertTotalTaskResults(expectedTotal : 0); CollectionAssert.AreEqual(cyclesCountBefore, cyclesCountAfter); }
public void Evaluate(ExpressionInfo expression, ITaskEngine taskEngine, Action <object> callback) { TaskInfo taskInfo = (TaskInfo)expression.Value; ExpressionInfo valueInfo = expression.Children[0]; ExpressionInfo outputInfo = expression.Children.Length > 1 ? expression.Children[1] : null; if (outputInfo == null) { outputInfo = new ExpressionInfo { Code = ExpressionCode.Value, Value = PrimitiveContract.Create(0) }; } IExpression valueExpression = taskEngine.GetExpression(valueInfo.Code); expression.IsEvaluating = true; valueExpression.Evaluate(valueInfo, taskEngine, value => { expression.IsEvaluating = false; int outputIndex = ((PrimitiveContract <int>)outputInfo.Value).Value; taskEngine.Memory.WriteOutput(taskInfo.Parent.TaskId, taskInfo.TaskId, outputIndex, value); callback(null); }); }
private void Dispose(bool disposing) { if (!mIsDisposed) { if (disposing) { StopFulfillingFiveYearPlanAsync() .Wait(); mEngine?.Dispose(); mEngine = null; mAppMetricsMonitor = null; mDbAssetFactory = null; IDisposable disposableAppMetricsMonitor = mAppMetricsMonitor as IDisposable; if (disposableAppMetricsMonitor != null) { disposableAppMetricsMonitor.Dispose(); } } mIsDisposed = true; } }
private void OnReadyToPlayAll(Error error, Player[] players, Guid[] localPlayers, VoxelAbilitiesArray[] abilities, SerializedTaskArray[] taskTemplates, SerializedTaskTemplatesArray[] TaskTemplateData, AssignmentGroupArray[] assignmentGroups, Room room) { if (m_matchServer.HasError(error)) { Error(error); m_matchServer.Disconnect(); return; } //if(m_rttInfo.RTT < GameConstants.MatchEngineTick) //{ // //In case of low rtt we offset client timer by one tick to the past // m_prevTickTime += GameConstants.MatchEngineTick; //} long maxPing = GameConstants.PingTimeout; if (m_rttInfo.RTTMax > maxPing) { Debug.LogWarningFormat("Ping is too high {0} ms", m_rttInfo.RTTMax * GameConstants.MatchEngineTick); //set max ping to RTT_MAX? } m_nextTickTime = Time.realtimeSinceStartup + Math.Max(0, (maxPing - m_rttInfo.RTTMax) / 4) * GameConstants.MatchEngineTick; m_cmdQueue = new CommandsQueue(maxPing); m_isInitialized = true; m_taskEngines = new ITaskEngine[players.Length]; m_pathFinders = new IPathFinder[players.Length]; m_taskRunners = new ITaskRunner[players.Length]; for (int i = 0; i < players.Length; ++i) { Player player = players[i]; if (player.IsBot || localPlayers.Contains(players[i].Id)) { ITaskRunner taskRunner = MatchFactoryCli.CreateTaskRunner(); m_taskRunners[i] = taskRunner; IPathFinder pathFinder = MatchFactoryCli.CreatePathFinder(m_map.Map); m_pathFinders[i] = pathFinder; ITaskEngine taskEngine = MatchFactoryCli.CreateTaskEngine(m_game, taskRunner, pathFinder); taskEngine.ClientRequest += ProcessClientRequest; m_taskEngines[i] = taskEngine; } } if (Started != null) { Started(new Error(StatusCode.OK), players, localPlayers, abilities, taskTemplates, TaskTemplateData, assignmentGroups, room); } enabled = true; //update method will be called }
public void Evaluate(ExpressionInfo expression, ITaskEngine taskEngine, Action <object> callback) { ExpressionInfo child = expression.Children[0]; expression.IsEvaluating = true; taskEngine.GetExpression(child.Code).Evaluate(child, taskEngine, value => { expression.IsEvaluating = false; callback(!((bool)value)); }); }
private void HandleTaskStateChanged(List <TaskStateInfo> taskStateInfo) { for (int i = 0; i < taskStateInfo.Count; ++i) { TaskStateInfo tsi = taskStateInfo[i]; ITaskEngine taskEngine = m_taskEngines[tsi.PlayerId]; if (taskEngine != null) { taskEngine.SetTaskState(tsi.TaskId, tsi.State, tsi.StatusCode); } } }
public BotController(Player player, ITaskEngine taskEngine, IBotStrategy strategy) { m_log = Dependencies.Logger; m_state = new State(); m_strategy = strategy; m_strategy.State = m_state; m_taskEngine = taskEngine; m_playerView = m_taskEngine.MatchEngine.GetPlayerView(player.Id); }
protected override void OnEvaluating(ExpressionInfo expression, ITaskEngine taskEngine, Action <object> callback) { ExpressionInfo left = expression.Children[0]; ExpressionInfo right = expression.Children[1]; taskEngine.GetExpression(left.Code).Evaluate(left, taskEngine, lvalue => { taskEngine.GetExpression(right.Code).Evaluate(right, taskEngine, rvalue => { OnEvaluating(lvalue, rvalue, callback); }); }); }
public void Evaluate(ExpressionInfo expression, ITaskEngine taskEngine, Action <object> callback) { if (expression.IsEvaluating) { throw new InvalidOperationException("expression.IsEvaluating == true"); } expression.IsEvaluating = true; OnEvaluating(expression, taskEngine, result => { expression.IsEvaluating = false; callback(result); }); }
public void Destroy() { for (int i = 0; i < m_players.Length; ++i) { IMatchPlayerController player = m_players[i]; ITaskEngine taskEngine = m_taskEngines[i]; taskEngine.TaskStateChanged -= OnTaskStateChanged; taskEngine.ClientRequest -= OnClientRequest; MatchFactory.DestroyTaskEngine(taskEngine); MatchFactory.DestroyPathFinder(m_pathFinders[i]); MatchFactory.DestroyTaskRunner(m_taskRunners[i]); } }
public async Task Invoke(HttpContext context, ITaskEngine engine) { try { await engine.RunOnBeginRequest(context.RequestAborted); await _next(context); await engine.RunOnEndRequest(context.RequestAborted); } catch (Exception e) { await engine.RunOnException(e, context.RequestAborted); throw; } }
public void Evaluate(ExpressionInfo expression, ITaskEngine taskEngine, Action <object> callback) { if (expression.Value is PrimitiveContract) { PrimitiveContract primitive = (PrimitiveContract)expression.Value; callback(primitive.ValueBase); } else if (expression.Value is TaskInputInfo) { TaskInputInfo input = (TaskInputInfo)expression.Value; object value = taskEngine.Memory.ReadOutput(input.Scope.TaskId, input.OutputTask.TaskId, input.OutputIndex); callback(value); } else { callback(expression.Value); } }
protected override void OnEvaluating(ExpressionInfo expression, ITaskEngine taskEngine, Action <object> callback) { ExpressionInfo left = expression.Children[0]; ExpressionInfo right = expression.Children[1]; taskEngine.GetExpression(left.Code).Evaluate(left, taskEngine, first => { taskEngine.GetExpression(right.Code).Evaluate(right, taskEngine, second => { long unitId = (long)first; int playerId = (int)second; IMatchPlayerView player = taskEngine.MatchEngine.GetPlayerView(playerId); IMatchUnitAssetView unit = player.GetUnitOrAsset(unitId); OnEvaluating(expression, player, unit, taskEngine, callback); }); }); }
public IEnumerator FindPathClientSideTaskTest() { BeginTest(TestEnv1, 2, 0, () => { MapRoot map = Dependencies.Map.Map; IMatchEngineCli matchEngineCli = Dependencies.MatchEngine; const int playerId = 1; Coordinate[] coords = map.FindDataOfType((int)KnownVoxelTypes.Eater, playerId); VoxelData data = map.Get(coords[0]); Coordinate targetCoordinate = coords[0].Add(1, -1); MovementCmd moveCmd = new MovementCmd(CmdCode.Move, data.UnitOrAssetIndex, 0); moveCmd.Coordinates = new[] { coords[0], targetCoordinate }; ITaskEngine taskEngine = matchEngineCli.GetClientTaskEngine(playerId); TaskEngineEvent <TaskInfo> taskStateChanged = null; taskStateChanged = taskStateInfo => { if (taskStateInfo.State == TaskState.Completed) { taskEngine.TaskStateChanged -= taskStateChanged; Coordinate[] newCoords = map.FindDataOfType((int)KnownVoxelTypes.Eater, playerId); Assert.AreEqual(targetCoordinate, newCoords[0]); EndTest(); } else { Assert.AreEqual(TaskState.Active, taskStateInfo.State); } }; taskEngine.TaskStateChanged += taskStateChanged; TaskInfo taskInfo = new TaskInfo(moveCmd, playerId); taskInfo.RequiresClientSidePreprocessing = true; taskEngine.SubmitTask(taskInfo); }); yield return(Run()); }
public async Task Test_DoWork_TasksWithErrors_UntilFataled(int workerCount) { ITaskQueueProducer producer = CreateTaskQueueProducer(); ITaskEngine taskEngine = CreateTaskEngine(workerCount); int expectedNumberOfErrors = taskEngine.Options .TaskProcessingOptions .FaultErrorThresholdCount + 2; CountdownEvent doneEvent = new CountdownEvent(20 * expectedNumberOfErrors); TestExecutorEventBus <AlwaysFailingTask> .Instance .ExecutorCompleted += (s, e) => doneEvent.Signal(); await taskEngine.StartAsync(); for (int i = 1; i <= 20; i++) { await producer.EnqueueAsync(new AlwaysFailingTask(), source : nameof(Test_DoWork_TasksWithErrors_UntilFataled), priority : 0); } doneEvent.Wait(); await taskEngine.StopAync(); await AssertTotalTasks(expectedTotal : 0); await AssertAllTasksCompletedWithStatus( expectedTaskResultCount : 20, expectedStatus : QueuedTaskStatus.Fatal, expectedErrorCount : expectedNumberOfErrors); await AssertCorrectExecutionCyclesCount <AlwaysFailingTask>(expectedCount : 20 *expectedNumberOfErrors); }
public async Task Test_DoWork_TasksWithErrors_CompletesSuccessfullyAfterFailures(int workerCount) { ITaskQueueProducer producer = CreateTaskQueueProducer(); ITaskEngine taskEngine = CreateTaskEngine(workerCount); int numberForErrorsBeforeSucceeding = taskEngine.Options .TaskProcessingOptions .FaultErrorThresholdCount - 1; CountdownEvent doneEvent = new CountdownEvent(20 * (numberForErrorsBeforeSucceeding + 1)); TestExecutorEventBus <FailsNTimesBeforeSucceeding> .Instance .ExecutorCompleted += (s, e) => doneEvent.Signal(); await taskEngine.StartAsync(); for (int i = 1; i <= 20; i++) { await producer.EnqueueAsync(new FailsNTimesBeforeSucceeding( Guid.NewGuid(), numberForErrorsBeforeSucceeding ), source : nameof(Test_DoWork_TasksWithErrors_CompletesSuccessfullyAfterFailures), priority : 0); } doneEvent.Wait(); await taskEngine.StopAync(); await AssertTotalTasks(expectedTotal : 0); await AssertAllTasksCompletedWithStatus(expectedTaskResultCount : 20, expectedStatus : QueuedTaskStatus.Processed, expectedErrorCount : numberForErrorsBeforeSucceeding); await AssertCorrectExecutionCyclesCount <FailsNTimesBeforeSucceeding>(expectedCount : 20 *(numberForErrorsBeforeSucceeding + 1)); }
public async Task <Stakhanovise> StartFulfillingFiveYearPlanAsync() { CheckNotDisposedOrThrow(); if (mDbAssetFactory == null) { mDbAssetFactory = mStakhanoviseSetup.BuildDbAssetFactory(); } if (mEngine == null) { mEngine = mStakhanoviseSetup.BuildTaskEngine(); } if (mAppMetricsMonitor == null) { mAppMetricsMonitor = mStakhanoviseSetup.BuildAppMetricsMonitor(); } if (mDbAssetFactory != null) { await mDbAssetFactory.CreateDbAssetsAsync(); } if (!mEngine.IsRunning) { await mEngine.StartAsync(); } if (mAppMetricsMonitor != null && !mAppMetricsMonitor.IsRunning && mEngine is IAppMetricsProvider) { await mAppMetricsMonitor.StartAsync(( IAppMetricsProvider )mEngine); } return(this); }
public MatchEngine(MapRoot map, int playersCount) { m_serializer = new ProtobufSerializer(); m_map = map; m_players = new IMatchPlayerController[playersCount]; m_map.SetPlayerCount(playersCount); m_taskEngines = new ITaskEngine[playersCount]; m_pathFinders = new IPathFinder[playersCount]; m_taskRunners = new ITaskRunner[playersCount]; for (int i = 0; i < playersCount; ++i) { IPathFinder pathFinder = MatchFactory.CreatePathFinder(m_map); ITaskRunner taskRunner = MatchFactory.CreateTaskRunner(); m_pathFinders[i] = pathFinder; m_taskRunners[i] = taskRunner; ITaskEngine taskEngine = MatchFactory.CreateTaskEngine(this, taskRunner, pathFinder); taskEngine.TaskStateChanged += OnTaskStateChanged; taskEngine.ClientRequest += OnClientRequest; m_taskEngines[i] = taskEngine; } }
public async Task Test_DoWork_TasksWithNoErrors(int workerCount) { CountdownEvent doneEvent = new CountdownEvent(20); ITaskQueueProducer producer = CreateTaskQueueProducer(); ITaskEngine taskEngine = CreateTaskEngine(workerCount); TestExecutorEventBus <ComputeFactorial> .Instance .ExecutorCompleted += (s, e) => doneEvent.Signal(); await taskEngine.StartAsync(); for (int i = 1; i <= 20; i++) { await producer.EnqueueAsync(new ComputeFactorial( i ), source : nameof(Test_DoWork_TasksWithNoErrors), priority : 0); } doneEvent.Wait(); await taskEngine.StopAync(); await AssertTotalTasks(expectedTotal : 0); await AssertAllTasksCompletedWithStatus( expectedTaskResultCount : 20, expectedStatus : QueuedTaskStatus.Processed, expectedErrorCount : 0); await AssertCorrectExecutionCyclesCount <ComputeFactorial>(expectedCount : 20); }
public void Evaluate(ExpressionInfo expression, ITaskEngine taskEngine, Action <object> callback) { TaskInfo taskInfo = (TaskInfo)expression.Value; callback(taskInfo.StatusCode); }
public static IBotController CreateBotController(Player player, ITaskEngine taskEngine, IBotStrategy strategy) { return(new BotController(player, taskEngine, strategy)); }
public static void DestroyTaskEngine(ITaskEngine taskEngine) { taskEngine.Destroy(); }
public IEnumerator TaskTest( int playerId, Func <TaskInputInfo, TaskInputInfo, TaskInfo> GetTestTaskInfo, bool shouldTaskBeFailed, Action <MapRoot> testStarted, Action <TaskInfo> rootTaskCompleted, Action <TaskInfo> childTaskCompleted = null, int unitNumber = 0, string testEnv = TestEnv2) { BeginTest(testEnv, 2, 0, () => { MapRoot map = Dependencies.Map.Map; testStarted(map); IMatchEngineCli matchEngineCli = Dependencies.MatchEngine; Coordinate[] coords = map.FindDataOfType((int)KnownVoxelTypes.Eater, playerId); VoxelData voxel = map.Get(coords[unitNumber]); TaskInfo unitIndexTask = TaskInfo.UnitOrAssetIndex(voxel.UnitOrAssetIndex); TaskInfo playerIndexTask = TaskInfo.EvalExpression(ExpressionInfo.PrimitiveVal(playerId)); TaskInputInfo unitIndexInput = new TaskInputInfo { OutputIndex = 0, OutputTask = unitIndexTask }; TaskInputInfo playerIndexInput = new TaskInputInfo { OutputIndex = 0, OutputTask = playerIndexTask }; TaskInfo testTaskInfo = GetTestTaskInfo(unitIndexInput, playerIndexInput); TaskInfo rootTask = TaskInfo.Procedure( playerIndexTask, unitIndexTask, testTaskInfo, TaskInfo.Return(ExpressionInfo.TaskStatus(testTaskInfo))); rootTask.SetParents(); rootTask.Initialize(playerId); ITaskEngine taskEngine = matchEngineCli.GetClientTaskEngine(playerId); TaskEngineEvent <TaskInfo> taskStateChanged = null; taskStateChanged = taskInfo => { if (taskInfo.State == TaskState.Completed) { if (taskInfo.TaskId == rootTask.TaskId) { Assert.AreEqual(shouldTaskBeFailed, taskInfo.IsFailed, taskInfo.ToString()); taskEngine.TaskStateChanged -= taskStateChanged; rootTaskCompleted(taskInfo); EndTest(); } else { if (childTaskCompleted != null) { childTaskCompleted(taskInfo); } } } else if (taskInfo.State != TaskState.Idle) { Assert.AreEqual(TaskState.Active, taskInfo.State, taskInfo.ToString()); } }; taskEngine.TaskStateChanged += taskStateChanged; taskEngine.SubmitTask(rootTask); }); yield return(Run()); }
public void Evaluate(ExpressionInfo expression, ITaskEngine taskEngine, Action <object> callback) { TaskInfo taskInfo = (TaskInfo)expression.Value; callback(taskInfo.Cmd.IsHardFailed); }
public void Evaluate(ExpressionInfo expression, ITaskEngine taskEngine, Action <object> callback) { TaskInfo taskInfo = (TaskInfo)expression.Value; callback(taskInfo.Cmd.ErrorCode == CmdResultCode.Success); }
protected override void OnEvaluating(ExpressionInfo expression, IMatchPlayerView player, IMatchUnitAssetView unit, ITaskEngine taskEngine, Action <object> callback) { ExpressionInfo target = expression.Children[2]; taskEngine.GetExpression(target.Code).Evaluate(target, taskEngine, targetType => { CmdResultCode can = unit.DataController.CanConvertImmediate((int)targetType); callback(can); }); }
protected override void OnEvaluating(ExpressionInfo expression, IMatchPlayerView player, IMatchUnitAssetView unit, ITaskEngine taskEngine, Action <object> callback) { CmdResultCode can = unit.DataController.CanSplit4Immediate(); callback(can); }