protected void SplitTaskCompleted(TaskInfo taskInfo)
{
Assert.DoesNotThrow(() =>
{
EndTest();
});
Assert.AreEqual(TaskState.Completed, taskInfo.State);
Assert.IsFalse(taskInfo.IsFailed);
const int playerId = 3;
IMatchUnitController controller = m_engine.GetUnitController(playerId, taskInfo.Cmd.UnitIndex);
Assert.IsNull(controller);
Coordinate[] coords = m_map.FindDataOfType((int)KnownVoxelTypes.Eater, playerId);
Assert.AreEqual(2, coords.Length);
for (int i = 0; i < coords.Length; ++i)
{
Assert.AreEqual(2, coords[i].Weight);
VoxelData data = m_map.Get(coords[i]);
Assert.IsNotNull(data);
Assert.AreEqual((int)KnownVoxelTypes.Eater, data.Type);
}
Assert.AreEqual(1, coords[0].MapPos.SqDistanceTo(coords[1].MapPos));
Assert.Pass();
}
public void DestroyAllUnitsAndAssets()
{
for (int i = 0; i < m_units.Length; ++i)
{
IMatchUnitController unit = m_units[i];
if (!unit.IsAlive)
{
continue;
}
Coordinate c = unit.DataController.Coordinate;
MapCell cell = m_engine.Map.Get(c.Row, c.Col, c.Weight);
cell.RemoveVoxelDataAndDecreaseHeight(unit.Data);
RemoveUnitController(true, unit);
}
m_units = new IMatchUnitController[0];
long[] assetIds = m_idToAsset.Keys.ToArray();
for (int i = 0; i < assetIds.Length; ++i)
{
long assetId = assetIds[i];
MatchAsset asset = m_idToAsset[assetId];
asset.Cell.RemoveVoxelDataAndDecreaseHeight(asset.VoxelData);
RemoveAsset(asset.VoxelData);
}
}
private bool RemoveUnitController(bool unitsChanged, IMatchUnitController unitController)
{
if (m_idToUnit.ContainsKey(unitController.Id))
{
if (VoxelData.IsControllableUnit(unitController.DataController.ControlledData.Type))
{
m_controllableUnitsCount--;
}
MatchFactory.DestroyUnitController(unitController);
m_idToUnit.Remove(unitController.Id);
unitsChanged = true;
if (unitController.Assignment != null)
{
AssignmentsController.RemoveAssignment(unitController, null);
}
if (unitController.TargetForAssignments != null)
{
AssignmentsController.RemoveTargetFromAssignments(unitController, null);
}
if (UnitRemoved != null)
{
UnitRemoved(unitController);
}
}
return(unitsChanged);
}
protected void DiminishTaskCompleted(TaskInfo taskInfo)
{
Assert.DoesNotThrow(() =>
{
EndTest();
});
Assert.AreEqual(TaskState.Completed, taskInfo.State);
Assert.IsFalse(taskInfo.IsFailed);
IMatchUnitController controller = m_engine.GetUnitController(1, taskInfo.Cmd.UnitIndex);
Assert.IsNotNull(controller);
Assert.AreEqual(controller.Data.Weight, 2);
Assert.Pass();
}
private void CreateUnitController(VoxelData voxelData, Coordinate coordinate)
{
voxelData.UnitOrAssetIndex = m_identity;
IMatchUnitController unit = MatchFactory.CreateUnitController(m_engine, coordinate, voxelData.Type, m_playerIndex, m_allAbilities);
m_idToUnit.Add(m_identity, unit);
if (VoxelData.IsControllableUnit(unit.DataController.ControlledData.Type))
{
m_controllableUnitsCount++;
}
unchecked
{
m_identity++;
}
if (UnitCreated != null)
{
UnitCreated(unit);
}
}
public bool IsSuitableCmdFor(Guid playerId, long unitIndex, int cmdCode)
{
IMatchPlayerController playerController;
if (m_idToPlayers.TryGetValue(playerId, out playerController))
{
IMatchUnitController unitController = playerController.GetUnitController(unitIndex);
if (unitController.Data.Type == (int)KnownVoxelTypes.Spawner)
{
return(false);
}
switch (cmdCode)
{
//case CmdCode.Automatic:
// return true;
case CmdCode.Convert:
return(unitController.DataController.CanConvertImmediate(-1) == CmdResultCode.Success);
case CmdCode.Grow:
return(unitController.DataController.CanGrowImmediate() == CmdResultCode.Success);
case CmdCode.Split4:
return(unitController.DataController.CanSplit4Immediate() == CmdResultCode.Success);
case CmdCode.Split:
return(unitController.DataController.CanSplitImmediate() == CmdResultCode.Success);
case CmdCode.Move:
return(!unitController.DataController.IsCollapsedOrBlocked);
case CmdCode.Explode:
return(unitController.Data.Type == (int)KnownVoxelTypes.Bomb);
}
}
return(false);
}
private bool PostprocessCmd(bool unitsChanged, IMatchUnitController unitController, Cmd cmd)
{
if (cmd.IsFailed)
{
return(unitsChanged);
}
if (cmd.Code == CmdCode.Split || cmd.Code == CmdCode.Split4)
{
CoordinateCmd splitCmd = (CoordinateCmd)cmd;
for (int c = 0; c < splitCmd.Coordinates.Length; ++c)
{
Coordinate coordinate = splitCmd.Coordinates[c];
VoxelData voxelData = m_engine.Map.Get(coordinate);
if (voxelData != null)
{
CreateUnitController(voxelData, coordinate);
unitsChanged = true;
}
}
}
else if (cmd.Code == CmdCode.Convert)
{
Coordinate coord = unitController.DataController.Coordinate;
MapCell cell = m_engine.Map.Get(coord.Row, coord.Col, coord.Weight);
VoxelData voxelData = cell.GetVoxelDataAt(coord.Altitude);
if (voxelData != null)
{
if (VoxelData.IsUnit(voxelData.Type))
{
CreateUnitController(voxelData, unitController.DataController.Coordinate);
unitsChanged = true;
}
else
{
CreateAsset(voxelData, cell);
}
}
}
else if (cmd.Code == CmdCode.CreateAssignment)
{
CreateAssignmentCmd addCmd = (CreateAssignmentCmd)cmd;
if (addCmd.CreatePreview)
{
Coordinate coord = addCmd.PreviewCoordinate;
MapCell cell = m_engine.Map.Get(coord.Row, coord.Col, coord.Weight);
VoxelData voxelData = cell.GetPreviewAt(m_playerIndex, coord.Altitude);
Debug.Assert(voxelData != null);
CreateUnitController(voxelData, coord);
addCmd.HasTarget = true;
addCmd.TargetId = voxelData.UnitOrAssetIndex;
addCmd.TargetPlayerIndex = voxelData.Owner;
}
m_assignmentController.CreateAssignment(addCmd.GroupId, addCmd.UnitIndex, addCmd.TaskLaunchInfo, addCmd.HasTarget, addCmd.TargetPlayerIndex, addCmd.TargetId);
}
return(unitsChanged);
}
public bool Tick(long tick, out CommandsArray commands)
{
m_isPlayerInRoom = !m_isPlayerLeftRoom;
bool isChanged = false;
if (m_units.Length != m_commandBuffer.Commands.Length)
{
m_commandBuffer = new CommandsArray(new Cmd[m_idToUnit.Count]);
}
bool unitsChanged = false;
for (int i = 0; i < m_units.Length; ++i)
{
IMatchUnitController unitController = m_units[i];
Cmd cmd;
unitController.Tick(tick, out cmd);
IList <VoxelDataCellPair> createdVoxels = unitController.CreatedVoxels;
if (createdVoxels.Count != 0)
{
CreateAssets(createdVoxels);
for (int j = 0; j < m_otherPlayerControllers.Length; ++j)
{
m_otherPlayerControllers[j].CreateAssets(createdVoxels);
}
}
IList <VoxelData> eatenOrDestroyed = unitController.EatenOrDestroyedVoxels;
if (eatenOrDestroyed.Count != 0)
{
RemoveAssets(eatenOrDestroyed);
for (int j = 0; j < m_otherPlayerControllers.Length; ++j)
{
m_otherPlayerControllers[j].RemoveAssets(eatenOrDestroyed);
}
}
m_commandBuffer.Commands[i] = cmd;
if (cmd != null)
{
isChanged = true;
if (cmd.Code == CmdCode.Composite)
{
CompositeCmd composite = (CompositeCmd)cmd;
for (int c = 0; c < composite.Commands.Length; ++c)
{
unitsChanged = PostprocessCmd(unitsChanged, unitController, composite.Commands[c]);
}
}
else
{
unitsChanged = PostprocessCmd(unitsChanged, unitController, cmd);
}
}
if (!unitController.IsAlive)
{
unitsChanged = RemoveUnitController(unitsChanged, unitController);
}
}
if (unitsChanged)
{
m_units = m_idToUnit.Values.ToArray();
}
commands = m_commandBuffer;
return(isChanged);
}
public static void DestroyUnitController(IMatchUnitController unitController)
{
unitController.Destroy();
}
