private void TargetSelectionSelect(int myPlayerIndex, int playerIndex, long unitIndex)
        {
            for (int i = 0; i < m_gameState.PlayersCount; ++i)
            {
                if (i == playerIndex)
                {
                    continue;
                }

                m_targetSelection.Select(myPlayerIndex, i, null);
            }

            m_targetSelection.Select(myPlayerIndex, playerIndex, new[] { unitIndex });
        }
Example #2
0
        private void Update()
        {
            if (m_gameState.IsActionsMenuOpened(LocalPlayerIndex))
            {
                if (!m_cameraController.IsInputEnabled)
                {
                    m_cameraController.IsInputEnabled = true;
                }
                return;
            }

            if (m_gameState.IsMenuOpened(LocalPlayerIndex))
            {
                if (!m_cameraController.IsInputEnabled)
                {
                    m_cameraController.IsInputEnabled = true;
                }
                return;
            }

            if (m_gameState.IsContextActionInProgress(LocalPlayerIndex))
            {
                if (!m_cameraController.IsInputEnabled)
                {
                    m_cameraController.IsInputEnabled = true;
                }
                return;
            }

            if (m_gameState.IsPaused || m_gameState.IsPauseStateChanging)
            {
                return;
            }

            if (m_gameState.IsReplay)
            {
                return;
            }

            int playerIndex = PlayerIndex;

            m_selectInterval   -= Time.deltaTime;
            m_unselectInterval -= Time.deltaTime;

            bool multiselect = m_inputManager.GetButton(InputAction.RB, LocalPlayerIndex);

            if (m_inputManager.GetButtonDown(InputAction.LMB, LocalPlayerIndex))
            {
                RaycastHit hitInfo;
                if (Physics.Raycast(m_cameraController.Ray, out hitInfo))
                {
                    Voxel voxel = hitInfo.transform.GetComponentInParent <Voxel>();
                    if (voxel != null)
                    {
                        VoxelData data = voxel.VoxelData;
                        if (VoxelData.IsControllableUnit(data.Type) && data.Owner == playerIndex)
                        {
                            m_unitSelection.ClearSelection(playerIndex);
                            m_unitSelection.Select(playerIndex, playerIndex, new[] { data.UnitOrAssetIndex });
                        }
                        else
                        {
                            m_unitSelection.ClearSelection(playerIndex);
                        }
                    }
                    else
                    {
                        m_unitSelection.ClearSelection(playerIndex);
                    }
                }
                else
                {
                    m_unitSelection.ClearSelection(playerIndex);
                }

                if (m_boxSelector != null)
                {
                    m_boxSelector.Activate();
                }
            }

            if (m_inputManager.GetButtonDown(InputAction.LB, LocalPlayerIndex))
            {
                bool select = true;

                if (multiselect)
                {
                    long[] units     = m_gameState.GetUnits(playerIndex).ToArray();
                    long   unitIndex = GetAt(units, m_cameraController.MapCursor);

                    if (m_unitSelection.IsSelected(playerIndex, playerIndex, unitIndex))
                    {
                        m_unitSelection.Unselect(playerIndex, playerIndex, new[] { unitIndex });
                        m_wasSelected.Remove(unitIndex);
                        select = false;
                    }
                }

                if (select)
                {
                    Select(playerIndex, multiselect);
                    m_selectInterval   = 0.3f;
                    m_unselectInterval = float.PositiveInfinity;
                    m_multiselectMode  = true;
                }
                else
                {
                    m_selectInterval   = float.PositiveInfinity;
                    m_unselectInterval = 0.3f;
                }
            }
            else if (m_inputManager.GetButton(InputAction.LB, LocalPlayerIndex))
            {
                if (m_selectInterval <= 0)
                {
                    Select(playerIndex, multiselect);
                    m_selectInterval = 0.2f;
                }

                if (m_unselectInterval <= 0)
                {
                    Unselect(playerIndex);
                    m_unselectInterval = 0.2f;
                }

                m_cameraController.IsInputEnabled = false;
            }
            else if (m_inputManager.GetButtonUp(InputAction.LB, LocalPlayerIndex, false, false))
            {
                m_cameraController.IsInputEnabled = true;
            }

            if (m_inputManager.GetButtonDown(InputAction.RB, LocalPlayerIndex))
            {
                m_multiselectMode = false;
            }
            else if (m_inputManager.GetButtonUp(InputAction.RB, LocalPlayerIndex))
            {
                if (!m_multiselectMode)
                {
                    if (!m_targetSelection.HasSelected(playerIndex))
                    {
                        m_wasSelected.Clear();
                        m_unitSelection.ClearSelection(playerIndex);
                    }
                }
            }
        }