protected void FinializeTest(int playerIndex, TaskInfo task, TaskEngineEvent <TaskInfo> callback, TaskEngineEvent <TaskInfo> childTaskCallback = null)
{
long identity = 0;
TaskEngine.GenerateIdentitifers(task, ref identity);
TaskEngineEvent <TaskInfo> taskStateChangedEventHandler = null;
taskStateChangedEventHandler = taskInfo =>
{
if (taskInfo.TaskId == task.TaskId)
{
if (taskInfo.State != TaskState.Active)
{
m_engine.GetTaskEngine(playerIndex).TaskStateChanged -= taskStateChangedEventHandler;
callback(taskInfo);
}
}
else
{
if (childTaskCallback != null)
{
childTaskCallback(taskInfo);
}
}
};
m_engine.GetTaskEngine(playerIndex).TaskStateChanged += taskStateChangedEventHandler;
m_engine.Submit(playerIndex, new TaskCmd(SerializedTask.FromTaskInfo(task)));
RunEngine();
Assert.Fail();
}
private void ExecuteGenericTaskTest(int cmdCode, TaskEngineEvent <TaskInfo> taskStateChangeEventHandler, bool begin = true, int playerId = 1)
{
ExecuteTaskTest(() =>
{
return(PrepareTestData2(playerId, cmdCode, 0));
}, taskStateChangeEventHandler, begin, playerId);
}
private void ExecuteTaskTest(Func <Cmd> runTestCallback, TaskEngineEvent <TaskInfo> taskStateChangeEventHandler, bool begin = true, int playerId = 1)
{
if (begin)
{
Assert.DoesNotThrow(() =>
{
BeginTest(TestEnv0, 4);
});
}
Cmd cmd = runTestCallback();
TaskInfo task = new TaskInfo(cmd);
FinializeTest(playerId, task, taskStateChangeEventHandler);
}
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 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 RepeatTaskTest(TaskInfo repeatChildTask, TaskInputInfo input, int iterations, int expectedIterations, TaskEngineEvent <TaskInfo> childTaskCallback = null, Action pass = null)
{
Assert.DoesNotThrow(() =>
{
BeginTest(TestEnv0, 4);
});
ExpressionInfo setToZero = ExpressionInfo.Val(PrimitiveContract.Create(0));
ExpressionInfo add = ExpressionInfo.Add(
ExpressionInfo.Val(input),
ExpressionInfo.Val(PrimitiveContract.Create(1)));
ExpressionInfo lessThanValue = ExpressionInfo.Lt(
ExpressionInfo.Val(input),
ExpressionInfo.Val(PrimitiveContract.Create(iterations)));
TaskInfo setToZeroTask = new TaskInfo
{
TaskType = TaskType.EvalExpression,
OutputsCount = 1,
Expression = setToZero,
};
input.OutputTask = setToZeroTask;
ExpressionInfo increment = ExpressionInfo.Assign(setToZeroTask, add);
TaskInfo incrementTask = new TaskInfo
{
TaskType = TaskType.EvalExpression,
Expression = increment,
OutputsCount = 1,
Inputs = new[] { input },
};
TaskInfo repeatTask = new TaskInfo();
repeatTask.TaskType = TaskType.Repeat;
repeatTask.Expression = lessThanValue;
repeatTask.Children = new[]
{
repeatChildTask,
incrementTask
};
TaskInfo task = new TaskInfo
{
TaskType = TaskType.Sequence,
Children = new[]
{
setToZeroTask,
repeatTask
}
};
task.SetParents();
const int playerId = 1;
task.Initialize(playerId);
//
//input.SetScope();
bool isIncremented = false;
BeginCleanupCheck(playerId);
FinializeTest(playerId, task, result =>
{
Assert.IsTrue(isIncremented);
Assert.AreEqual(TaskState.Completed, result.State);
Assert.IsFalse(result.IsFailed);
CleanupCheck(playerId);
if (pass != null)
{
pass();
}
Assert.Pass();
},
childTask =>
{
if (childTask.TaskId == repeatTask.TaskId && childTask.State == TaskState.Completed)
{
ITaskMemory memory = m_engine.GetTaskEngine(playerId).Memory;
Assert.AreEqual(expectedIterations, memory.ReadOutput(setToZeroTask.Parent.TaskId, setToZeroTask.TaskId, 0));
isIncremented = true;
}
else
{
if (childTaskCallback != null)
{
childTaskCallback(childTask);
}
}
});
}
public IEnumerator SearchForFoodTaskTest(int playerId, Action <ITaskEngine, TaskInfo, TaskInfo, Coordinate[]> callback)
{
BeginTest(TestEnv1, 2, 0, () =>
{
MapRoot map = Dependencies.Map.Map;
IMatchEngineCli matchEngineCli = Dependencies.MatchEngine;
Coordinate[] coords = map.FindDataOfType((int)KnownVoxelTypes.Eater, playerId);
VoxelData voxel = map.Get(coords[0]);
TaskInfo searchForFoodTask = new TaskInfo(TaskType.SearchForFood)
{
OutputsCount = 2
};
TaskInputInfo searchForFoodContext = new TaskInputInfo
{
OutputIndex = 0,
OutputTask = searchForFoodTask,
};
TaskInfo getUnitIndexTask = new TaskInfo(TaskType.EvalExpression)
{
Expression = ExpressionInfo.PrimitiveVal(voxel.UnitOrAssetIndex),
OutputsCount = 1
};
TaskInputInfo unitIndex = new TaskInputInfo
{
OutputIndex = 0,
OutputTask = getUnitIndexTask
};
searchForFoodTask.Inputs = new[] { searchForFoodContext, unitIndex };
TaskInfo rootTask = new TaskInfo(TaskType.Sequence)
{
Children = new[] { getUnitIndexTask, searchForFoodTask }
};
rootTask.SetParents();
rootTask.Initialize(playerId);
ITaskEngine taskEngine = matchEngineCli.GetClientTaskEngine(playerId);
TaskEngineEvent <TaskInfo> taskStateChanged = null;
taskStateChanged = taskInfo =>
{
if (taskInfo.State == TaskState.Completed)
{
if (taskInfo.TaskId == searchForFoodTask.TaskId)
{
callback(taskEngine, taskInfo, searchForFoodTask, coords);
}
else if (taskInfo.TaskId == rootTask.TaskId)
{
taskEngine.TaskStateChanged -= taskStateChanged;
EndTest();
}
}
else
{
Assert.AreEqual(TaskState.Active, taskInfo.State);
}
};
taskEngine.TaskStateChanged += taskStateChanged;
taskEngine.SubmitTask(rootTask);
});
yield return(Run());
}
