public static TaskInfo HealMoveToCoordGrow(Coordinate[] path, TaskInputInfo unitIndexInput, TaskInputInfo playerIndexInput)
{
TaskInfo taskInfo = TaskInfo.Procedure
(
TaskInfo.SetHealth(unitIndexInput, 64),
MoveToCoordinate(path, unitIndexInput, playerIndexInput),
TaskInfo.Grow(unitIndexInput),
TaskInfo.Return(ExpressionInfo.PrimitiveVal(TaskInfo.TaskSucceded))
);
taskInfo.Inputs = new TaskInputInfo[] { unitIndexInput, playerIndexInput };
return(taskInfo);
}
TaskInfo IBotSubmitTask.SubmitTask(float time, IMatchUnitAssetView unit, TaskTemplateType type, params TaskInfo[] parameters)
{
if (m_state.BusyUnits[(KnownVoxelTypes)unit.Data.Type].ContainsKey(unit.Id))
{
throw new InvalidOperationException("unit " + unit.Id + " of type " + (KnownVoxelTypes)unit.Data.Type + " is busy");
}
TaskInfo taskInfo = m_state.TaskTemplates[type].Acquire();
TaskInfo unitIdTask = TaskInfo.EvalExpression(ExpressionInfo.PrimitiveVal(unit.Id));
TaskInfo playerIdTask = TaskInfo.EvalExpression(ExpressionInfo.PrimitiveVal(m_playerView.Index));
taskInfo.Children[0] = unitIdTask;
taskInfo.Children[1] = playerIdTask;
int argsLength = parameters != null ? parameters.Length : 0;
TaskInfo rootTask = taskInfo.Children[2 + argsLength];
if (rootTask == null || taskInfo.Children.Length <= argsLength + 1 || taskInfo.Children[argsLength + 1] != null)
{
throw new ArgumentException("wrong number of arguments for task template: " + type, "type");
}
rootTask.Inputs[0].OutputTask = unitIdTask;
rootTask.Inputs[1].OutputTask = playerIdTask;
if (parameters != null)
{
for (int i = 0; i < parameters.Length; ++i)
{
TaskInfo define = parameters[i];
define.Inputs[0].ExtensionSocket = rootTask.Inputs[0];
define.Inputs[1].ExtensionSocket = rootTask.Inputs[1];
taskInfo.Children[2 + i] = define;
taskInfo.Children[2 + parameters.Length].Inputs[2 + i].OutputTask = define;
}
}
taskInfo.SetParents();
taskInfo.Initialize(m_playerView.Index);
m_state.FreeUnits[(KnownVoxelTypes)unit.Data.Type].Remove(unit.Id);
m_state.BusyUnits[(KnownVoxelTypes)unit.Data.Type].Add(unit.Id, unit);
m_taskEngine.SubmitTask(taskInfo);
RunningTaskInfo runningTaskInfo = new RunningTaskInfo(type, unit, taskInfo.TaskId, time);
m_state.TaskIdToTask.Add(taskInfo.TaskId, runningTaskInfo);
m_state.UnitIdToTask.Add(unit.Id, runningTaskInfo);
return(taskInfo);
}
public void ExpreessionInfoCloneTest2()
{
ExpressionInfo canRun = ExpressionInfo.Eq(
ExpressionInfo.PrimitiveVal(CmdResultCode.Success),
ExpressionInfo.Val(new TaskInputInfo()));
Assert.DoesNotThrow(() =>
{
TaskInfo task = new TaskInfo {
Expression = canRun
};
byte[] b = m_protobufSerializer.Serialize(SerializedTask.FromTaskInfo(task));
SerializedTask.ToTaskInfo(m_protobufSerializer.Deserialize <SerializedTask>(b));
});
}
public static TaskInfo SearchAndMoveAnyway(Coordinate[] waypoints, TaskInputInfo unitIndexInput, TaskInputInfo playerIndexInput)
{
TaskInfo defineGoalTask = TaskInfo.EvalExpression(ExpressionInfo.Val(waypoints));
TaskInfo findPathTask = TaskInfo.FindPath(unitIndexInput, new TaskInputInfo(defineGoalTask, 0));
TaskInfo taskInfo = TaskInfo.Procedure
(
defineGoalTask,
findPathTask,
TaskInfo.Move(unitIndexInput, new TaskInputInfo(findPathTask, 0)),
TaskInfo.Return(ExpressionInfo.PrimitiveVal(TaskInfo.TaskSucceded))
);
taskInfo.Inputs = new TaskInputInfo[] { unitIndexInput, playerIndexInput };
return(taskInfo);
}
public void RepeatProcedureReturnTest()
{
Assert.DoesNotThrow(() =>
{
BeginTest(TestEnv0, 4);
});
TaskInfo procedure = TaskInfo.Procedure(
TaskInfo.Repeat(
ExpressionInfo.PrimitiveVal(true),
new TaskInfo(TaskType.TEST_Mock),
new TaskInfo(TaskType.TEST_MockImmediate),
new TaskInfo(TaskType.TEST_MockImmediate),
TaskInfo.Return(ExpressionInfo.PrimitiveVal(TaskInfo.TaskSucceded)),
new TaskInfo(TaskType.TEST_Fail)
)
);
TaskInfo root = TaskInfo.Sequence
(
procedure,
TaskInfo.Branch(
ExpressionInfo.TaskSucceded(procedure),
new TaskInfo(TaskType.Nop),
new TaskInfo(TaskType.TEST_Fail)
)
);
root.SetParents();
const int playerId = 1;
BeginCleanupCheck(playerId);
FinializeTest(playerId, root, result =>
{
Assert.AreEqual(root.TaskId, result.TaskId);
Assert.AreEqual(TaskState.Completed, result.State);
Assert.IsFalse(result.IsFailed);
CleanupCheck(playerId);
Assert.Pass();
},
childTask =>
{
});
}
public void SearchForPathCloneTest2()
{
TaskInfo searchForTask = TaskInfo.SearchFor(TaskType.SearchForFood, new TaskInputInfo());
ExpressionInfo searchForSucceded = ExpressionInfo.TaskSucceded(searchForTask);
TaskInputInfo coordinateInput = new TaskInputInfo(searchForTask, 1);
TaskInfo findPathTask = TaskInfo.FindPath(new TaskInputInfo(), coordinateInput);
ExpressionInfo findPathSucceded = ExpressionInfo.TaskSucceded(findPathTask);
TaskInputInfo pathVariableInput = new TaskInputInfo(findPathTask, 0);
ExpressionInfo assignPathVariable = ExpressionInfo.Assign(
TaskInfo.Var(),
ExpressionInfo.Val(pathVariableInput));
ExpressionInfo whileTrue = ExpressionInfo.PrimitiveVal(true);
TaskInfo task =
TaskInfo.Procedure(
TaskInfo.Repeat(
whileTrue,
searchForTask,
TaskInfo.Branch(
searchForSucceded,
TaskInfo.Sequence(
findPathTask,
TaskInfo.Branch(
findPathSucceded,
TaskInfo.Sequence(
TaskInfo.EvalExpression(assignPathVariable),
TaskInfo.Return()
),
TaskInfo.Continue()
)
),
TaskInfo.Return(ExpressionInfo.PrimitiveVal(TaskInfo.TaskFailed))
)
)
);
Assert.DoesNotThrow(() =>
{
SerializedTask.ToTaskInfo(m_protobufSerializer.DeepClone(SerializedTask.FromTaskInfo(task)));
});
}
public void ContinueInSequenceTest()
{
Assert.DoesNotThrow(() =>
{
BeginTest(TestEnv0, 4);
});
const int playerId = 2;
ExpressionInfo expr = ExpressionInfo.PrimitiveVal(true);
TaskInfo task = TaskInfo.Repeat(expr);
task.Children = new[]
{
new TaskInfo(TaskType.TEST_Mock),
new TaskInfo(TaskType.TEST_Mock),
TaskInfo.Sequence
(
new TaskInfo(TaskType.TEST_MockImmediate),
TaskInfo.Assert((tb, ti) =>
{
expr = TaskInfo.FindById(task.TaskId, ti.Root).Expression;
expr.Value = PrimitiveContract.Create(false);
return(TaskState.Completed);
}),
TaskInfo.Continue(),
new TaskInfo(TaskType.TEST_Fail)
),
new TaskInfo(TaskType.TEST_MockImmediate),
new TaskInfo(TaskType.TEST_MockImmediate)
};
BeginCleanupCheck(playerId);
FinializeTest(playerId, task, result =>
{
Assert.AreEqual(TaskState.Completed, result.State);
Assert.IsFalse(result.IsFailed);
CleanupCheck(playerId);
Assert.Pass();
});
}
private TaskInfo PathToRandomLocation(TaskInputInfo unitIndexInput, TaskInputInfo playerInput)
{
int radius = 3;
TaskInfo radiusVar = TaskInfo.EvalExpression(ExpressionInfo.PrimitiveVal(radius));
TaskInputInfo radiusInput = new TaskInputInfo
{
OutputIndex = 0,
OutputTask = radiusVar
};
TaskInfo pathToRandomLocation = TaskInfo.PathToRandomLocation(unitIndexInput, radiusInput);
TaskInputInfo pathInput = new TaskInputInfo
{
OutputIndex = 0,
OutputTask = pathToRandomLocation
};
TaskInfo assert = TaskInfo.Assert((taskBase, taskInfo) =>
{
Coordinate[] path = taskBase.ReadInput <Coordinate[]>(taskInfo.Inputs[0]);
Assert.IsNotNull(path);
Assert.IsTrue(path.Length > 1);
Coordinate first = path[0];
Coordinate last = path[path.Length - 1];
Assert.LessOrEqual(Mathf.Abs(first.Row - last.Row), 3);
Assert.LessOrEqual(Mathf.Abs(first.Col - last.Col), 3);
return(TaskState.Completed);
});
assert.Inputs = new[] { pathInput };
return(TaskInfo.Sequence(
radiusVar,
pathToRandomLocation,
TaskInfo.Branch(
ExpressionInfo.TaskSucceded(pathToRandomLocation),
assert,
new TaskInfo(TaskType.TEST_Fail)
)
));
}
private TaskInfo SearchForTestTargetAndMove(TaskInputInfo unitIndexInput, TaskInputInfo playerIndexInput)
{
TaskInfo pathVar = TaskInfo.Var();
TaskInfo searhForPathTask = TaskInfo.SearchForPath(TaskType.TEST_SearchForWall, pathVar, unitIndexInput);
ExpressionInfo pathFound = ExpressionInfo.TaskSucceded(searhForPathTask);
TaskInputInfo pathInput = new TaskInputInfo(pathVar, 0);
TaskInfo moveTask = TaskInfo.Move(unitIndexInput, pathInput);
return(TaskInfo.Procedure(
pathVar,
TaskInfo.Log("search for path started"),
searhForPathTask,
TaskInfo.Log(
ExpressionInfo.Add(
ExpressionInfo.PrimitiveVal("path found ? "),
pathFound)
),
moveTask,
TaskInfo.Return(ExpressionInfo.TaskStatus(moveTask))
));
}
public void ProcedureRepeatBranchSearchCloneTest()
{
ExpressionInfo whileTrue = ExpressionInfo.PrimitiveVal(true);
TaskInfo searchForTask = TaskInfo.SearchFor(TaskType.SearchForFood, new TaskInputInfo());
TaskInfo task =
TaskInfo.Procedure(
TaskInfo.Repeat(
whileTrue,
searchForTask,
TaskInfo.Branch(
whileTrue,
new TaskInfo()
)
)
);
Assert.DoesNotThrow(() =>
{
SerializedTask.ToTaskInfo(m_protobufSerializer.DeepClone(SerializedTask.FromTaskInfo(task)));
});
}
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 IterateRepeatTest()
{
Assert.DoesNotThrow(() =>
{
BeginTest(TestEnv0, 4);
});
List <int> integers = new List <int>()
{
1, 2, 3, 4, 5
};
TaskInfo iterateTask = new TaskInfo
{
TaskType = TaskType.EvalExpression,
Expression = ExpressionInfo.Iterate(integers),
OutputsCount = 1,
};
TaskInputInfo input = new TaskInputInfo
{
OutputIndex = 0,
OutputTask = iterateTask,
};
ExpressionInfo isTrue = ExpressionInfo.Eq(
ExpressionInfo.Val(PrimitiveContract.Create(true)),
ExpressionInfo.Get(
ExpressionInfo.Val(input),
ExpressionInfo.PrimitiveVal("IsLast")));
TaskInfo breakIfCompleted = new TaskInfo
{
TaskType = TaskType.Branch,
Expression = isTrue,
Children = new[]
{
new TaskInfo
{
TaskType = TaskType.Break,
},
null
}
};
TaskInfo repeat = new TaskInfo
{
TaskType = TaskType.Repeat,
Expression = ExpressionInfo.PrimitiveVal(true),
Children = new[]
{
iterateTask,
breakIfCompleted,
}
};
repeat.SetParents();
input.SetScope();
const int playerId = 1;
bool isIterated = false;
int counter = 0;
BeginCleanupCheck(playerId);
FinializeTest(playerId, repeat, result =>
{
Assert.IsTrue(isIterated);
Assert.AreEqual(TaskState.Completed, result.State);
Assert.IsFalse(result.IsFailed);
CleanupCheck(playerId);
Assert.Pass();
},
childTask =>
{
if (childTask.TaskId == iterateTask.TaskId && childTask.State == TaskState.Completed)
{
counter++;
ITaskMemory memory = m_engine.GetTaskEngine(playerId).Memory;
IterationResult iterResult = (IterationResult)memory.ReadOutput(iterateTask.Parent.TaskId, iterateTask.TaskId, 0);
if (iterResult.IsLast)
{
isIterated = true;
Assert.IsNull(iterResult.Object);
}
else
{
Assert.AreEqual(counter, (int)iterResult.Object);
}
}
});
}
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());
}
public IEnumerator SearchMoveOrRandomMoveLimitedRandomSearchesFailTest()
{
yield return(TaskTest(1, (unitIndexInput, playerId) =>
{
const int maxRandLocationPicks = 10;
const int maxRandMovements = 0;
TaskInfo randomMovementsVar = TaskInfo.Var();
TaskInputInfo randomMovementsInput = new TaskInputInfo(randomMovementsVar, 0);
TaskInfo searchMoveOrRandomMove = TaskInfo.SearchMoveOrRandomMove(TaskType.SearchForFood, unitIndexInput, maxRandLocationPicks, randomMovementsInput, maxRandMovements);
return TaskInfo.Procedure(
randomMovementsVar,
TaskInfo.EvalExpression(ExpressionInfo.Assign(randomMovementsVar, ExpressionInfo.PrimitiveVal(0))),
searchMoveOrRandomMove,
TaskInfo.Return(ExpressionInfo.TaskStatus(searchMoveOrRandomMove))
);
}
, true,
rootTaskInfo =>
{
Assert.AreEqual(TaskState.Completed, rootTaskInfo.State);
Assert.IsTrue(rootTaskInfo.IsFailed);
}));
}