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); }