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);
}
