private void CreateAsset(VoxelData voxelData, VoxelAbilities abilities, MapCell cell)
{
if (voxelData.IsNeutral)
{
return;
}
voxelData.UnitOrAssetIndex = m_identity;
MatchAssetCli asset = new MatchAssetCli(voxelData, abilities, cell);
m_voxelDataToId.Add(voxelData, m_identity);
m_idToAsset.Add(m_identity, asset);
unchecked
{
m_identity++;
}
if (voxelData.Weight >= GameConstants.MinVoxelActorWeight)
{
Coordinate coordinate = new Coordinate(cell, voxelData);
int radius = abilities.VisionRadius;
m_voxelMap.Map.ForEachInRadius(coordinate, radius, (observedCell, pos) =>
{
ObserveCell(asset.VoxelData.Owner, observedCell, pos, coordinate.Weight);
});
m_minimap.Spawn(voxelData, new Coordinate(cell, voxelData));
}
if (AssetCreated != null)
{
AssetCreated(asset);
}
}
private void RemoveAsset(VoxelData voxelData)
{
if (voxelData.IsNeutral)
{
return;
}
long id;
if (m_voxelDataToId.TryGetValue(voxelData, out id))
{
m_voxelDataToId.Remove(voxelData);
MatchAssetCli asset = m_idToAsset[id];
if (asset.VoxelData.Weight >= GameConstants.MinVoxelActorWeight)
{
Coordinate coordinate = new Coordinate(asset.Cell, asset.VoxelData);
int radius = asset.Abilities.VisionRadius;
m_voxelMap.Map.ForEachInRadius(coordinate, radius, (ignoredCell, pos) =>
{
IgnoreCell(asset.VoxelData.Owner, ignoredCell, pos, coordinate.Weight);
});
m_minimap.Die(voxelData, new Coordinate(asset.Cell, voxelData));
}
m_idToAsset.Remove(id);
if (asset.Assignment != null)
{
AssignmentsController.RemoveAssignment(asset, DieCallback);
}
if (asset.TargetForAssignments != null)
{
AssignmentsController.RemoveTargetFromAssignments(asset, DieCallback);
}
if (AssetRemoved != null)
{
AssetRemoved(asset);
}
asset.Destroy();
}
}
private void UnselectAsTarget(int selectorIndex, long[] ids)
{
for (int i = 0; i < ids.Length; ++i)
{
long id = ids[i];
IMatchUnitControllerCli unitController;
if (m_idToUnit.TryGetValue(id, out unitController))
{
unitController.UnselectAsTarget(selectorIndex);
}
else
{
MatchAssetCli asset = m_idToAsset[id];
asset.UnselectAsTarget(selectorIndex);
}
}
}
private void GetUnitOrAsset(int playerIndex, long unitOrAssetIndex, ref VoxelData data, ref MapPos mapPos)
{
IVoxelDataController controller = m_gameState.GetVoxelDataController(playerIndex, unitOrAssetIndex);
if (controller != null)
{
data = controller.ControlledData;
mapPos = controller.Coordinate.MapPos;
}
else
{
MatchAssetCli asset = m_gameState.GetAsset(playerIndex, unitOrAssetIndex);
if (asset != null)
{
data = asset.VoxelData;
mapPos = asset.Cell.GetPosition();
}
}
}
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 CreateMovementCmd(bool serverSide, Action <List <Cmd> > callback)
{
Guid playerId = m_gameState.GetLocalPlayerId(m_localPlayerIndex);
int playerIndex = m_gameState.GetPlayerIndex(playerId);
long[] selectedUnitIds = m_unitSelection.GetSelection(playerIndex, playerIndex);
if (selectedUnitIds.Length > 0)
{
List <Cmd> commandsToSubmit = new List <Cmd>();
for (int i = 0; i < selectedUnitIds.Length; ++i)
{
long unitIndex = selectedUnitIds[i];
IVoxelDataController dataController = m_gameState.GetVoxelDataController(playerIndex, unitIndex);
MapCell cell = m_map.GetCell(m_cameraController.MapCursor, m_cameraController.Weight, null);
int deltaWeight = dataController.ControlledData.Weight - m_cameraController.Weight;
while (deltaWeight > 0)
{
cell = cell.Parent;
deltaWeight--;
}
VoxelData selectedTarget = null;
//MapCell selectedTargetCell = null;
for (int p = 0; p < m_gameState.PlayersCount; ++p)
{
long[] targetSelection = m_targetSelection.GetSelection(playerIndex, p);
if (targetSelection.Length > 0)
{
MatchAssetCli asset = m_gameState.GetAsset(p, targetSelection[0]);
if (asset != null)
{
selectedTarget = asset.VoxelData;
// selectedTargetCell = asset.Cell;
}
else
{
IVoxelDataController dc = m_gameState.GetVoxelDataController(p, targetSelection[0]);
selectedTarget = dc.ControlledData;
// selectedTargetCell = m_map.GetCell(dc.Coordinate.MapPos, dc.Coordinate.Weight, null);
}
}
}
int dataType = dataController.ControlledData.Type;
int dataWeight = dataController.ControlledData.Weight;
VoxelData beneath = null;
if (cell != null)
{
if (selectedTarget == null)
{
VoxelData defaultTarget;
beneath = cell.GetDefaultTargetFor(dataType, dataWeight, playerIndex, false, out defaultTarget);
}
else
{
beneath = cell.GetPreviousFor(selectedTarget, dataType, dataWeight, playerIndex);
}
}
VoxelData closestBeneath = beneath;
float minDistance = float.MaxValue;
if (closestBeneath == null && cell != null)
{
MapPos pos = cell.GetPosition();
for (int r = -1; r <= 1; r++)
{
for (int c = -1; c <= 1; c++)
{
MapCell neighbourCell = m_map.GetCell(new MapPos(pos.Row + r, pos.Col + c), dataController.ControlledData.Weight, null);
if (neighbourCell != null)
{
VoxelData defaultTarget;
VoxelData data = neighbourCell.GetDefaultTargetFor(dataType, dataWeight, playerIndex, false, out defaultTarget);
Vector3 worldPoint = m_map.GetWorldPosition(new MapPos(pos.Row + r, pos.Col + c), dataWeight);
if (data != null)
{
worldPoint.y = (data.Altitude + data.Height) * GameConstants.UnitSize;
}
Vector2 screenPoint = m_cameraController.WorldToScreenPoint(worldPoint);
if (m_cameraController.InScreenBounds(screenPoint))
{
float distance = (screenPoint - m_cameraController.VirtualMousePosition).magnitude;
if (data != null && distance < minDistance)
{
minDistance = distance;
closestBeneath = data;
cell = neighbourCell;
}
}
}
}
}
}
beneath = closestBeneath;
if (beneath != null)
{
int weight = dataController.ControlledData.Weight;
// Vector3 hitPoint = beneath.Weight <= weight ? m_map.GetWorldPosition(m_cameraController.MapCursor, m_cameraController.Weight) : m_cameraController.Cursor;
//MapPos mapPos = m_map.GetMapPosition(hitPoint, weight);
MapPos mapPos = cell.GetPosition();
int altitude = beneath.Altitude + beneath.Height;
if (serverSide)
{
MovementCmd movementCmd = new MovementCmd();
if (selectedTarget != null)
{
movementCmd.HasTarget = true;
movementCmd.TargetIndex = selectedTarget.UnitOrAssetIndex;
movementCmd.TargetPlayerIndex = selectedTarget.Owner;
}
Coordinate targetCoordinate = new Coordinate(mapPos, weight, altitude);
movementCmd.Code = CmdCode.Move;
movementCmd.Coordinates = new[] { targetCoordinate };
movementCmd.UnitIndex = unitIndex;
commandsToSubmit.Add(movementCmd);
}
else
{
Coordinate targetCoordinate = new Coordinate(mapPos, weight, altitude);
m_engine.GetPathFinder(m_gameState.LocalToPlayerIndex(LocalPlayerIndex)).Find(unitIndex, -1, dataController.Clone(), new[] { dataController.Coordinate, targetCoordinate },
(unitId, path) =>
{
MovementCmd movementCmd = new MovementCmd();
movementCmd.Code = CmdCode.Move;
movementCmd.Coordinates = path;
movementCmd.UnitIndex = unitIndex;
commandsToSubmit.Add(movementCmd);
callback(commandsToSubmit);
},
null);
}
}
}
if (serverSide)
{
callback(commandsToSubmit);
}
}
callback(null);
}
private void Explode(int targetPlayerIndex, long targetIndex, Coordinate to)
{
VoxelData explodeData;
IVoxelDataController dataController = m_game.GetVoxelDataController(targetPlayerIndex, targetIndex);
if (dataController != null)
{
explodeData = dataController.ControlledData;
}
else
{
MatchAssetCli asset = m_game.GetAsset(targetPlayerIndex, targetIndex);
explodeData = asset.VoxelData;
}
CmdResultCode noFail = m_dataController.Explode(to, explodeData, EatOrDestroyCallback, ExpandCallback, ExplodeCallback);
if (noFail != CmdResultCode.Success)
{
throw new InvalidOperationException();
}
VoxelData voxelData = m_dataController.ControlledData;
MapPos mapPos = m_dataController.Coordinate.MapPos;
int weight = m_dataController.Coordinate.Weight;
Debug.Assert(weight == m_dataController.ControlledData.Weight);
// AcquireReleaseVisibility(voxelData, mapPos, weight);
if (m_controlledVoxel == null)
{
CollapseEatExpandClear(m_currentTick);
}
else
{
Collapse(m_currentTick, 0);
//this code moved above m_controlldeVoxel.Kill to prevent cleanup of eatables
EatAndExpand(m_currentTick, 0);
//if (m_controlledVoxel != null)
//{
// m_controlledVoxel.Explode(0);
//}
if (explodeData.VoxelRef != null)
{
//explodeData.VoxelRef.Explode(0);
VoxelData next = explodeData.Next;
while (next != null)
{
if (next.VoxelRef != null)
{
next.VoxelRef.ChangeAltitude(next.VoxelRef.Altitude, next.Altitude, m_currentCmdDuration);
}
next = next.Next;
}
}
}
Explode(0);
}
