private int[] m_offsetIndices = { 0, 1, 2, 3 };//, 4, 5, 6, 7 };
public void FindEmptySpace(long unitId, IVoxelDataController dataController, int radius, Action <long, Coordinate[]> callback, Action <long> terminateCallback)
{
int[] offsetIndices = m_offsetIndices.OrderBy(x => m_rand.Next()).ToArray();
for (int r = 1; r <= radius; ++r)
{
for (int o = 0; o < offsetIndices.Length; ++o)
{
int offsetIndex = offsetIndices[o];
int deltaRow = m_offsets[offsetIndex, 0] * r;
int deltaCol = m_offsets[offsetIndex, 1] * r;
Coordinate coordinate = dataController.Coordinate;
coordinate = coordinate.Add(deltaRow, deltaCol);
if (dataController.IsValidAndEmpty(coordinate, false))
{
Find(unitId, -1, dataController, new[] { dataController.Coordinate, coordinate }, callback, terminateCallback);
return;
}
}
}
if (callback != null)
{
//fail
callback(unitId, new[] { dataController.Coordinate });
}
}
protected override void OnConstruct()
{
SearchAroundContext ctx = ReadInput <SearchAroundContext>(m_taskInfo.Inputs[0]);
long unitIndex = ReadInput <long>(m_taskInfo.Inputs[1]);
m_unit = m_taskEngine.MatchEngine.GetPlayerView(m_taskInfo.PlayerIndex).GetUnit(unitIndex);
if (m_unit == null)
{
m_taskInfo.StatusCode = TaskInfo.TaskFailed;
m_taskInfo.State = TaskState.Completed;
}
else
{
m_dataController = m_unit.DataController.Clone();
int mapSize = m_dataController.Map.GetMapSizeWith(m_unit.Data.Weight);
if (ctx == null)
{
ctx = new SearchAroundContext(m_unit.Position, mapSize, m_unit.Data.Weight, StartRadius, GetMaxRadius(m_unit));
}
m_taskEngine.TaskRunner.Run(unitIndex, -1, ctx, FindSuitableData, FindSuitableDataCompleted, (id, context) =>
{
if (m_taskInfo.State == TaskState.Active)
{
Debug.Assert(false, "Task Runner should not be interrupted when task is in active state");
m_taskInfo.StatusCode = TaskInfo.TaskFailed;
m_taskInfo.State = TaskState.Completed;
}
});
}
}
private Vector3 GetUnitPosition(int playerIndex, long unitIndex)
{
IVoxelDataController controller = m_gameState.GetVoxelDataController(playerIndex, unitIndex);
Vector3 position = m_map.GetWorldPosition(controller.Coordinate);
return(position);
}
public static IMatchUnitController CreateUnitController(IMatchEngine engine, Coordinate coordinate, int type, int playerIndex, Dictionary <int, VoxelAbilities>[] allAbilities)
{
IVoxelDataController dataController = CreateVoxelDataController(engine.Map, coordinate, type, playerIndex, allAbilities);
if (type == (int)KnownVoxelTypes.Eater)
{
return(new VoxelActorUnitController(dataController, engine));
}
else if (type == (int)KnownVoxelTypes.Bomb)
{
return(new VoxelBombUnitController(dataController, engine));
}
else if (type == (int)KnownVoxelTypes.Spawner)
{
return(new SpawnerUnitController(dataController));
}
else if ((type & (int)KnownVoxelTypes.Preview) != 0)
{
return(new PreviewUnitController(dataController));
}
else
{
throw new System.NotSupportedException(string.Format("Type {0} is not supported", type));
}
}
private void Start()
{
LocalPlayerIndex = m_viewport.LocalPlayerIndex;
m_boxSelector = Dependencies.GameView.GetBoxSelector(LocalPlayerIndex);
GetViewportAndCamera();
ReadPlayerCamSettings();
SetCameraPosition();
InitCameraPixelRect();
CreateAndInitVoxelCamera();
InitPivot();
int playerIndex = m_gameState.LocalToPlayerIndex(LocalPlayerIndex);
var units = m_gameState.GetUnits(playerIndex);
foreach (long unit in units)
{
IVoxelDataController dc = m_gameState.GetVoxelDataController(playerIndex, unit);
if (VoxelData.IsControllableUnit(dc.ControlledData.Type))
{
MapPivot = dc.Coordinate.ToWeight(GameConstants.MinVoxelActorWeight).MapPos;
break;
}
}
}
public MatchUnitControllerBase(IVoxelDataController dataController)
{
m_dataController = dataController;
m_commandsQueue = new Queue <Cmd>();
m_createdVoxels = new List <VoxelDataCellPair>();
m_eatenOrDestroyedVoxels = new List <VoxelData>();
}
private void OnSplit()
{
SubmitStdCommand(() => new Cmd(CmdCode.Split), (playerIndex, unitId) =>
{
IVoxelDataController dataController = m_gameState.GetVoxelDataController(playerIndex, unitId);
if (dataController.CanSplitImmediate() != CmdResultCode.Success)
{
Debug.LogWarning("Can't split unit " + unitId);
return(false);
}
return(true);
});
}
private void Select(int playerIndex, bool multiselect)
{
long[] units = m_gameState.GetUnits(playerIndex).ToArray();
long selectedIndex = -1;
long[] selection = m_unitSelection.GetSelection(playerIndex, playerIndex);
if (selection.Length > 0)
{
selectedIndex = selection[0];
}
if (!multiselect)
{
if (m_mapCursor != m_cameraController.MapCursor)
{
m_wasSelected.Clear();
}
}
VoxelData unitData = FindClosestTo(PlayerIndex, selectedIndex, units, false);
if (unitData != null)
{
if (m_wasSelected.Count == 0)
{
m_unitSelection.Select(playerIndex, playerIndex, new[] { unitData.UnitOrAssetIndex });
}
else
{
m_unitSelection.AddToSelection(playerIndex, playerIndex, new[] { unitData.UnitOrAssetIndex });
}
m_wasSelected.Add(unitData.UnitOrAssetIndex);
if (m_wasSelected.Count == 1)
{
IVoxelDataController dc = m_gameState.GetVoxelDataController(playerIndex, unitData.UnitOrAssetIndex);
Coordinate coord = dc.Coordinate;
coord = coord.ToWeight(m_cameraController.Weight);
coord.Altitude += dc.ControlledData.Height;
m_cameraController.MapPivot = coord.MapPos;
m_cameraController.SetVirtualMousePosition(coord, true, false);
m_mapCursor = m_cameraController.MapCursor;
}
}
}
public MatchUnitControllerBaseCli(IVoxelDataController dataController)
{
m_dataController = dataController;
m_controlledVoxel = m_dataController.ControlledData.VoxelRef;
OnSubscribe();
m_dataController.ControlledData.VoxelRefSet += OnVoxelRefSet;
m_dataController.ControlledData.VoxelRefReset += OnVoxelRefReset;
m_voxelMap = Dependencies.Map;
m_voxelFactory = Dependencies.VoxelFactory;
m_game = Dependencies.GameState;
}
private long GetAt(long[] units, MapPos position)
{
int playerIndex = PlayerIndex;
for (int i = 0; i < units.Length; ++i)
{
long unitIndex = units[i];
IVoxelDataController controller = m_gameState.GetVoxelDataController(playerIndex, unitIndex);
if (controller.Coordinate.MapPos == new Coordinate(position, m_cameraController.Weight, 0).ToWeight(controller.Coordinate.Weight).MapPos)
{
return(unitIndex);
}
}
return(-1);
}
public void Find(long unitId, long targetId, IVoxelDataController dataController,
Coordinate[] waypoints, Action <long, Coordinate[]> callback, Action <long> terminateCallback)
{
if (waypoints == null)
{
throw new ArgumentNullException("waypoints");
}
PathFinderTask task;
if (m_idToActiveTask.TryGetValue(unitId, out task))
{
task.Terminate();
m_activeTasks.Remove(task);
}
task = new PathFinderTask(dataController.PlayerIndex, unitId, targetId, dataController.Map, dataController.MapSize, dataController.ControlledData, waypoints[0] /*dataController.Coordinate*/, dataController.Abilities, waypoints, m_matrixPools, callback, terminateCallback);
m_idToActiveTask[unitId] = task;
m_activeTasks.Add(task);
}
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();
}
}
}
private void HandleCoordinateChange(IVoxelDataController dc, Coordinate prevCoord, int radius)
{
if (prevCoord.Weight != dc.Coordinate.Weight)
{
m_voxelMap.Map.ForEachInRadius(prevCoord, radius, (ignoredCell, pos) =>
{
IgnoreCell(dc.ControlledData.Owner, ignoredCell, pos, prevCoord.Weight);
});
m_voxelMap.Map.ForEachInRadius(dc.Coordinate, radius, (observedCell, pos) =>
{
ObserveCell(dc.ControlledData.Owner, observedCell, pos, dc.Coordinate.Weight);
});
}
else if (prevCoord.Row != dc.Coordinate.Row)
{
Debug.Assert(Mathf.Abs(prevCoord.Row - dc.Coordinate.Row) == 1);
m_voxelMap.Map.ForEachColInRadius(prevCoord, radius * (int)Mathf.Sign(dc.Coordinate.Row - prevCoord.Row), (ignoredCell, pos) =>
{
IgnoreCell(dc.ControlledData.Owner, ignoredCell, pos, prevCoord.Weight);
});
m_voxelMap.Map.ForEachColInRadius(dc.Coordinate, -radius * (int)Mathf.Sign(dc.Coordinate.Row - prevCoord.Row), (observedCell, pos) =>
{
ObserveCell(dc.ControlledData.Owner, observedCell, pos, dc.Coordinate.Weight);
});
}
else if (prevCoord.Col != dc.Coordinate.Col)
{
Debug.Assert(Mathf.Abs(prevCoord.Col - dc.Coordinate.Col) == 1);
m_voxelMap.Map.ForEachRowInRadius(prevCoord, radius * (int)Mathf.Sign(dc.Coordinate.Col - prevCoord.Col), (ignoredCell, pos) =>
{
IgnoreCell(dc.ControlledData.Owner, ignoredCell, pos, prevCoord.Weight);
});
m_voxelMap.Map.ForEachRowInRadius(dc.Coordinate, -radius * (int)Mathf.Sign(dc.Coordinate.Col - prevCoord.Col), (observedCell, pos) =>
{
ObserveCell(dc.ControlledData.Owner, observedCell, pos, dc.Coordinate.Weight);
});
}
m_minimap.Move(dc.ControlledData, prevCoord, dc.Coordinate);
}
private void ConvertUnitTo(int type)
{
SubmitStdCommand(() => new ChangeParamsCmd(CmdCode.Convert)
{
IntParams = new int[] { type }
},
(playerIndex, unitId) =>
{
int controllableUnitsCount = m_gameState.GetStats(playerIndex).ControllableUnitsCount;
long[] selection = m_unitSelection.GetSelection(playerIndex, playerIndex);
IVoxelDataController dataController = m_gameState.GetVoxelDataController(playerIndex, unitId);
if (dataController.CanConvertImmediate(type) != CmdResultCode.Success || selection.Length == controllableUnitsCount)
{
Debug.LogWarning("Can't convert unit " + unitId + " to " + type);
return(false);
}
return(true);
});
}
public PlayerStats GetStats(int index)
{
PlayerStats stats = m_playerStats[index];
long[] units = m_playerControllers[index].Units.OfType <IMatchUnitAssetView>().Select(uav => uav.Id).ToArray();
int count = 0;
for (int i = 0; i < units.Length; ++i)
{
IVoxelDataController dc = GetVoxelDataController(index, units[i]);
if (dc != null && VoxelData.IsControllableUnit(dc.ControlledData.Type) && dc.IsAlive)
{
count++;
}
}
stats.ControllableUnitsCount = count;
return(stats);
}
private void UpdateState()
{
int playerIndex = m_gameState.LocalToPlayerIndex(LocalPlayerIndex);
long[] selection = m_selection.GetSelection(playerIndex, playerIndex);
if (selection.Length == 0)
{
IsOpen = false;
return;
}
m_cancelBtn.gameObject.SetActive(selection.Length > 0);
m_attackBtn.gameObject.SetActive(selection.Length > 0);
m_moveBtn.gameObject.SetActive(selection.Length > 0);
m_autoBtn.gameObject.SetActive(selection.Length > 0);
m_bombBtn.gameObject.SetActive(false);
m_wallBtn.gameObject.SetActive(false);
m_spawnButton.gameObject.SetActive(false);
m_growButton.gameObject.SetActive(false);
m_diminishButton.gameObject.SetActive(false);
m_splitButton.gameObject.SetActive(false);
m_split4Button.gameObject.SetActive(false);
HUDControlBehavior hcbBomb = m_bombBtn.GetComponent <HUDControlBehavior>();
HUDControlBehavior hcbWall = m_wallBtn.GetComponent <HUDControlBehavior>();
HUDControlBehavior hcbSpawn = m_spawnButton.GetComponent <HUDControlBehavior>();
HUDControlBehavior hcbGrow = m_growButton.GetComponent <HUDControlBehavior>();
HUDControlBehavior hcbDiminish = m_diminishButton.GetComponent <HUDControlBehavior>();
HUDControlBehavior hcbSplit = m_splitButton.GetComponent <HUDControlBehavior>();
HUDControlBehavior hcbSplit4 = m_split4Button.GetComponent <HUDControlBehavior>();
hcbBomb.IsDisabled = true;
hcbWall.IsDisabled = true;
hcbSpawn.IsDisabled = true;
hcbGrow.IsDisabled = true;
hcbDiminish.IsDisabled = true;
hcbSplit.IsDisabled = true;
hcbSplit4.IsDisabled = true;
for (int i = 0; i < selection.Length; ++i)
{
IVoxelDataController dc = m_gameState.GetVoxelDataController(playerIndex, selection[i]);
if (dc != null)
{
CmdResultCode canBomb = dc.CanConvertImmediate((int)KnownVoxelTypes.Bomb);
if (canBomb != CmdResultCode.Fail_NotSupported)
{
m_bombBtn.gameObject.SetActive(true);
if (canBomb == CmdResultCode.Success)
{
hcbBomb.IsDisabled = false;
}
}
CmdResultCode canGround = dc.CanConvertImmediate((int)KnownVoxelTypes.Ground);
if (canGround != CmdResultCode.Fail_NotSupported)
{
m_wallBtn.gameObject.SetActive(true);
if (canGround == CmdResultCode.Success)
{
hcbWall.IsDisabled = false;
}
}
CmdResultCode canSpawner = dc.CanConvertImmediate((int)KnownVoxelTypes.Spawner);
if (canSpawner != CmdResultCode.Fail_NotSupported)
{
m_spawnButton.gameObject.SetActive(true);
if (canSpawner == CmdResultCode.Success)
{
hcbSpawn.IsDisabled = false;
}
}
CmdResultCode canGrow = dc.CanGrowImmediate();
if (canGrow != CmdResultCode.Fail_NotSupported)
{
m_growButton.gameObject.SetActive(true);
if (canGrow == CmdResultCode.Success)
{
hcbGrow.IsDisabled = false;
}
}
CmdResultCode canDiminish = dc.CanDiminishImmediate();
if (canDiminish != CmdResultCode.Fail_NotSupported)
{
m_diminishButton.gameObject.SetActive(true);
if (canDiminish == CmdResultCode.Success)
{
hcbDiminish.IsDisabled = false;
}
}
CmdResultCode canSplit = dc.CanSplitImmediate();
if (canSplit != CmdResultCode.Fail_NotSupported)
{
m_splitButton.gameObject.SetActive(true);
if (canSplit == CmdResultCode.Success)
{
hcbSplit.IsDisabled = false;
}
}
CmdResultCode canSplit4 = dc.CanSplit4Immediate();
if (canSplit4 != CmdResultCode.Fail_NotSupported)
{
m_split4Button.gameObject.SetActive(true);
if (canSplit4 == CmdResultCode.Success)
{
hcbSplit4.IsDisabled = false;
}
}
}
}
if (m_eventSystem.currentSelectedGameObject != null && m_eventSystem.currentSelectedGameObject.GetComponent <HUDControlBehavior>().IsDisabled)
{
m_eventSystem.SetSelectedGameObjectOnLateUpdate(m_autoBtn.gameObject);
}
}
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);
}
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);
}
}
}
public SpawnerUnitController(IVoxelDataController dataController)
: base(dataController)
{
m_ticksBeforeNextCommand = dataController.Abilities.ActionInterval;
}
private void ProcessRequest(ClientRequest request, Action <ClientRequest> callback)
{
Cmd cmd = request.Cmd;
if (cmd != null)
{
if (cmd.Code == CmdCode.GrantBotCtrl)
{
m_bots = new IBotController[m_game.PlayersCount];
for (int i = 0; i < m_bots.Length; ++i)
{
Player player = m_game.GetPlayer(i);
if (player.IsActiveBot)
{
IBotController bot = MatchFactoryCli.CreateBotController(player, m_taskEngines[i], new DefaultStrategy());
bot.Init();
m_bots[i] = bot;
}
}
callback(request);
}
else if (cmd.Code == CmdCode.DenyBotCtrl)
{
m_bots = new IBotController[m_game.PlayersCount];
for (int i = 0; i < m_bots.Length; ++i)
{
IBotController bot = m_bots[i];
if (bot != null)
{
bot.Reset();
}
}
m_bots = null;
callback(request);
}
else
{
IVoxelDataController dc = m_game.GetVoxelDataController(request.PlayerIndex, cmd.UnitIndex);
if (cmd.Code != CmdCode.Move || dc == null)
{
if (dc == null)
{
request.Cmd.ErrorCode = CmdResultCode.Fail_NoUnit;
}
else
{
request.Cmd.ErrorCode = CmdResultCode.Fail_NotSupported;
}
SubmitResponse(request);
}
else
{
CoordinateCmd coordinateCmd = (CoordinateCmd)cmd;
Debug.Assert(coordinateCmd.Coordinates.Length > 1);
IPathFinder pathFinder = m_pathFinders[request.PlayerIndex];
#warning PathFinder should igore dataController.ControlledVoxelData
pathFinder.Find(cmd.UnitIndex, -1, dc.Clone(), coordinateCmd.Coordinates, (unitIndex, path) =>
{
coordinateCmd.Coordinates = path;
request.Cmd = coordinateCmd;
callback(request);
}, null);
}
}
}
}
public VoxelBombUnitController(IVoxelDataController dataController, IMatchEngine engine)
: base(dataController, engine)
{
}
public SpawnerUnitControllerCli(IVoxelDataController dataController)
: base(dataController)
{
}
public PreviewUnitControllerCli(IVoxelDataController dataController)
: base(dataController)
{
}
public BombUnitControllerCli(IVoxelDataController dataController)
: base(dataController)
{
m_game = Dependencies.GameState;
}
private VoxelData FindClosestTo(int playerIndex, long selectedIndex, long[] units, bool unselectMode)
{
MapPos mapCursor = m_cameraController.MapCursor;
Vector3 selectedPosition;
if (selectedIndex == -1 || m_mapCursor != mapCursor)
{
selectedPosition = m_cameraController.Cursor;
}
else
{
selectedPosition = GetUnitPosition(playerIndex, selectedIndex);
}
float minDistance = float.PositiveInfinity;
long closestIndex = -1;
VoxelData closestVoxelData = null;
Plane[] planes = GeometryUtility.CalculateFrustumPlanes(m_viewport.Camera);
for (int i = 0; i < units.Length; ++i)
{
long unitIndex = units[i];
if (unselectMode)
{
if (!m_wasSelected.Contains(unitIndex))
{
continue;
}
}
else
{
if (m_wasSelected.Contains(unitIndex))
{
continue;
}
if (unitIndex == selectedIndex && m_mapCursor != mapCursor)
{
continue;
}
}
IVoxelDataController controller = m_gameState.GetVoxelDataController(playerIndex, unitIndex);
Vector3 position = m_map.GetWorldPosition(controller.Coordinate);
if (IsVisible(planes, controller.ControlledData.VoxelRef) && VoxelData.IsControllableUnit(controller.ControlledData.Type))
{
Vector3 toVector = (position - selectedPosition);
float distance = toVector.sqrMagnitude;
if (distance < minDistance)
{
minDistance = distance;
closestIndex = unitIndex;
closestVoxelData = controller.ControlledData;
}
}
}
return(closestVoxelData);
}
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);
}
private void Update()
{
if (m_gameState.IsActionsMenuOpened(LocalPlayerIndex))
{
return;
}
if (m_gameState.IsMenuOpened(LocalPlayerIndex))
{
return;
}
if (m_gameState.IsContextActionInProgress(LocalPlayerIndex))
{
return;
}
if (m_gameState.IsPaused || m_gameState.IsPauseStateChanging)
{
return;
}
int playerIndex = PlayerIndex;
if (m_mapCursor != m_cameraController.MapCursor)
{
m_mapCursor = m_cameraController.MapCursor;
VoxelData newSelectedTarget = null;
VoxelData target = null;
int width = m_map.Map.GetMapSizeWith(GameConstants.MinVoxelActorWeight);
if (m_mapCursor.Row >= 0 && m_mapCursor.Col >= 0 && m_mapCursor.Row < width && m_mapCursor.Col < width)
{
MapCell cell = m_map.Map.Get(m_mapCursor.Row, m_mapCursor.Col, m_cameraController.Weight);
for (int i = 0; i < m_selectedUnitDescriptors.Length; ++i)
{
SelectionDescriptor descriptor = m_selectedUnitDescriptors[i];
bool lowestPossible = true;
cell.GetDefaultTargetFor(descriptor.Type, descriptor.Weight, playerIndex, lowestPossible, out target, playerIndex);
if (target != null)
{
break;
}
}
}
if (target != null && target.VoxelRef != null && target.UnitOrAssetIndex != -1)
{
//Player could not destroy own units (and should not be able to select them as target)
if (!VoxelData.IsControllableUnit(target.Type) || target.Owner != playerIndex)
{
newSelectedTarget = target;
}
}
if (m_previouslySelected != newSelectedTarget)
{
if (newSelectedTarget == null)
{
ClearSelection();
m_selectedTarget = null;
m_previouslySelected = null;
}
else
{
m_previouslySelected = newSelectedTarget;
TryEnableTargetAutoSelectionMode();
if (m_isTargetAutoSelectionMode)
{
m_selectedTarget = newSelectedTarget;
TargetSelectionSelect(playerIndex, target.Owner, m_selectedTarget.UnitOrAssetIndex);
}
}
}
}
else
{
if (m_selectedTarget != null)
{
IVoxelDataController dc = m_gameState.GetVoxelDataController(m_selectedTarget.Owner, m_selectedTarget.UnitOrAssetIndex);
if (dc != null && dc.IsAlive)
{
Coordinate cursorCoord = new Coordinate(m_cameraController.MapCursor, GameConstants.MinVoxelActorWeight, 0).ToWeight(dc.ControlledData.Weight);
if (cursorCoord.MapPos != dc.Coordinate.MapPos)
{
Coordinate coord = dc.Coordinate.ToWeight(GameConstants.MinVoxelActorWeight);
m_cameraController.MapPivot = coord.MapPos;
m_cameraController.SetVirtualMousePosition(coord, true, false);
m_mapCursor = m_cameraController.MapCursor;
}
}
}
}
if (m_inputManager.GetButtonDown(InputAction.X, LocalPlayerIndex))
{
bool hasSelected = m_targetSelection.HasSelected(playerIndex);
Select(playerIndex);
if (!hasSelected)
{
m_isTargetAutoSelectionMode = true;
}
}
else if (m_inputManager.GetButtonUp(InputAction.RB, LocalPlayerIndex))
{
m_isTargetAutoSelectionMode = false;
ClearSelection();
}
}
public VoxelActorUnitControllerCli(IVoxelDataController dataController)
: base(dataController)
{
}
protected override void OnReleased()
{
base.OnReleased();
m_unit = null;
m_dataController = null;
}
public VoxelActorUnitController(IVoxelDataController dataController, IMatchEngine engine)
: base(dataController)
{
m_engine = engine;
m_pathFinder = m_engine.GetPathFinder(dataController.PlayerIndex);
}
