private void CreateUnitController(VoxelData voxelData, Coordinate coordinate)
{
voxelData.UnitOrAssetIndex = m_identity;
IMatchUnitControllerCli unit = MatchFactoryCli.CreateUnitController(m_voxelMap.Map, coordinate, voxelData.Type, m_playerIndex, m_allAbilities);
if (VoxelData.IsControllableUnit(voxelData.Type))
{
m_controllableUnitsCount++;
}
m_idToUnit.Add(m_identity, unit);
int radius = unit.DataController.Abilities.VisionRadius;
m_voxelMap.Map.ForEachInRadius(coordinate, radius, (observedCell, pos) =>
{
ObserveCell(unit.DataController.ControlledData.Owner, observedCell, pos, coordinate.Weight);
});
m_minimap.Spawn(voxelData, coordinate);
unchecked
{
m_identity++;
}
if (UnitCreated != null)
{
UnitCreated(unit);
}
}
public void DestroyAllUnitsAndAssets()
{
long[] unitIds = m_idToUnit.Keys.ToArray();
for (int i = 0; i < unitIds.Length; ++i)
{
long unitId = unitIds[i];
IMatchUnitControllerCli unit = m_idToUnit[unitId];
if (!unit.DataController.IsAlive)
{
continue;
}
Coordinate c = unit.DataController.Coordinate;
MapCell cell = m_voxelMap.Map.Get(c.Row, c.Col, c.Weight);
cell.RemoveVoxelDataAndDecreaseHeight(unit.DataController.ControlledData);
if (unit.DataController.ControlledData.VoxelRef != null)
{
unit.DataController.ControlledData.VoxelRef.Explode(1.0f, unit.DataController.ControlledData.Health);
}
RemoveUnitController(unitId);
}
long[] assetIds = m_idToAsset.Keys.ToArray();
for (int i = 0; i < assetIds.Length; ++i)
{
long assetId = assetIds[i];
MatchAssetCli asset = m_idToAsset[assetId];
asset.Cell.RemoveVoxelDataAndDecreaseHeight(asset.VoxelData);
if (asset.VoxelData.VoxelRef != null)
{
asset.VoxelData.VoxelRef.Explode(0, asset.VoxelData.Health);
}
RemoveAsset(asset.VoxelData);
}
}
private void RemoveUnitController(long unitId)
{
IMatchUnitControllerCli unitController = m_idToUnit[unitId];
if (VoxelData.IsControllableUnit(unitController.Type))
{
m_controllableUnitsCount--;
}
Coordinate coordinate = unitController.DataController.Coordinate;
int radius = unitController.DataController.Abilities.VisionRadius;
m_voxelMap.Map.ForEachInRadius(coordinate, radius, (ignoredCell, pos) =>
{
IgnoreCell(unitController.DataController.ControlledData.Owner, ignoredCell, pos, coordinate.Weight);
});
m_minimap.Die(unitController.DataController.ControlledData, unitController.DataController.Coordinate);
m_idToUnit.Remove(unitId);
//Does not needed because all nessesary actions and event unsubscription performed in OnVoxelRefReset event handler
//MatchFactoryCli.DestroyUnitController(unitController);
if (unitController.Assignment != null)
{
AssignmentsController.RemoveAssignment(unitController, DieCallback);
}
if (unitController.TargetForAssignments != null)
{
AssignmentsController.RemoveTargetFromAssignments(unitController, DieCallback);
}
if (UnitRemoved != null)
{
UnitRemoved(unitController);
}
}
public static void DestroyUnitController(IMatchUnitControllerCli controller)
{
controller.Destroy();
}
private List <long> PostprocessCommand(List <long> spawnedUnitsList, Cmd cmd, IMatchUnitControllerCli unitController)
{
if (cmd.Code == CmdCode.Split || cmd.Code == CmdCode.Split4)
{
CoordinateCmd splitCmd = (CoordinateCmd)cmd;
for (int i = 0; i < splitCmd.Coordinates.Length; ++i)
{
Coordinate coordinate = splitCmd.Coordinates[i];
VoxelData voxelData = m_voxelMap.Map.Get(coordinate);
if (voxelData != null)
{
if (spawnedUnitsList == null)
{
spawnedUnitsList = new List <long>();
}
spawnedUnitsList.Add(m_identity);
CreateUnitController(voxelData, coordinate);
}
}
}
else if (cmd.Code == CmdCode.Convert)
{
Coordinate coordinate = unitController.DataController.Coordinate;
MapCell cell = m_voxelMap.Map.Get(coordinate.Row, coordinate.Col, coordinate.Weight);
VoxelData voxelData = cell.GetVoxelDataAt(coordinate.Altitude);
if (voxelData != null)
{
if (VoxelData.IsUnit(voxelData.Type))
{
if (spawnedUnitsList == null)
{
spawnedUnitsList = new List <long>();
}
spawnedUnitsList.Add(m_identity);
CreateUnitController(voxelData, coordinate);
}
else
{
CreateAsset(voxelData, m_allAbilities[voxelData.Owner][voxelData.Type], cell);
}
}
}
else if (cmd.Code == CmdCode.CreateAssignment)
{
CreateAssignmentCmd addCmd = (CreateAssignmentCmd)cmd;
if (addCmd.CreatePreview)
{
Coordinate coord = addCmd.PreviewCoordinate;
MapCell cell = m_voxelMap.Map.Get(coord.Row, coord.Col, coord.Weight);
VoxelData voxelData = cell.GetPreviewAt(m_playerIndex, coord.Altitude);
Debug.Assert(voxelData != null);
if (spawnedUnitsList == null)
{
spawnedUnitsList = new List <long>();
}
spawnedUnitsList.Add(m_identity);
CreateUnitController(voxelData, coord);
}
AssignmentsController.CreateAssignment(addCmd.GroupId, addCmd.UnitIndex, addCmd.TaskLaunchInfo, addCmd.HasTarget, addCmd.TargetPlayerIndex, addCmd.TargetId);
}
return(spawnedUnitsList);
}
public void Execute(Cmd[] commands, long tick, long lagTicks)
{
HashSet <long> deadUnitsHs = null;
List <long> spawnedUnitsList = null;
for (int c = 0; c < commands.Length; ++c)
{
Cmd cmd = commands[c];
if (cmd == null)
{
continue;
}
if (cmd.Code == CmdCode.LeaveRoom)
{
m_isInRoom = false;
}
else
{
IMatchUnitControllerCli unitController = m_idToUnit[cmd.UnitIndex];
long duration = cmd.Duration;
duration -= lagTicks;
duration = Math.Max(0, duration);
cmd.Duration = (int)duration;
IVoxelDataController dc = unitController.DataController;
Coordinate prevCoord = dc.Coordinate;
int radius = unitController.DataController.Abilities.VisionRadius;
unitController.ExecuteCommand(cmd, tick);
if (prevCoord != dc.Coordinate)
{
HandleCoordinateChange(dc, prevCoord, radius);
}
IList <VoxelDataCellPair> createdVoxels = unitController.CreatedVoxels;
if (createdVoxels.Count != 0)
{
CreateAssets(createdVoxels);
for (int i = 0; i < m_otherPlayerControllers.Length; ++i)
{
m_otherPlayerControllers[i].CreateAssets(createdVoxels);
}
}
IList <VoxelData> eatenOrDestroyed = unitController.EatenOrDestroyedVoxels;
if (eatenOrDestroyed.Count != 0)
{
RemoveAssets(eatenOrDestroyed);
for (int i = 0; i < m_otherPlayerControllers.Length; ++i)
{
m_otherPlayerControllers[i].RemoveAssets(eatenOrDestroyed);
}
}
if (cmd.Code == CmdCode.Composite)
{
CompositeCmd compositeCmd = (CompositeCmd)cmd;
for (int i = 0; i < compositeCmd.Commands.Length; ++i)
{
spawnedUnitsList = PostprocessCommand(spawnedUnitsList, compositeCmd.Commands[i], unitController);
}
}
else
{
spawnedUnitsList = PostprocessCommand(spawnedUnitsList, cmd, unitController);
}
//if (unitController.DataController.ControlledData.Unit.State == VoxelDataState.Dead)
if (!unitController.DataController.IsAlive)
{
//Voxel voxel = unitController.DataController.ControlledData.VoxelRef;
//Debug.Assert(voxel == null);//
if (deadUnitsHs == null)
{
deadUnitsHs = new HashSet <long>();
}
if (deadUnitsHs.Contains(cmd.UnitIndex))
{
Debug.LogError("Dead unit could not execute commands");
}
else
{
deadUnitsHs.Add(cmd.UnitIndex);
}
}
}
}
if (deadUnitsHs != null)
{
long[] deadUnits = deadUnitsHs.ToArray();
for (int i = 0; i < m_gameState.PlayersCount; ++i)
{
m_selection.Unselect(i, m_playerIndex, deadUnits);
m_targetSelection.Unselect(i, m_playerIndex, deadUnits);
}
for (int i = 0; i < deadUnits.Length; ++i)
{
long unitId = deadUnits[i];
RemoveUnitController(unitId);
}
}
if (m_isLocalPlayer)
{
if (spawnedUnitsList != null)
{
long[] spawnedUnits = spawnedUnitsList.ToArray();
spawnedUnits = spawnedUnits.Where(
u => m_gameState.GetVoxelDataController(m_playerIndex, u) != null &&
VoxelData.IsControllableUnit(m_gameState.GetVoxelDataController(m_playerIndex, u).ControlledData.Type)).ToArray();
m_selection.AddToSelection(m_playerIndex, m_playerIndex, spawnedUnits);
}
}
}
