예제 #1
0
        /// <summary>
        /// Удалить связь с ячейкой
        /// </summary>
        /// <param name="linkedCell">Связаная ячейка</param>
        public void UnlinkCell(CellBehaviour linkedCell)
        {
            //Определить тип горизонтального направления к ячейке по вектору направления
            Vector3 dirToLinkedCell = (transform.position - linkedCell.transform.position).normalized;

            GridTools.HorizontalDirections hDir = GridTools.GetHorizontalDirectionByVector(dirToLinkedCell);

            RemoveLink(hDir, linkedCell.GetCellData().RootCell);
        }
예제 #2
0
        CellBehaviour CreateCell(int i, int j)
        {
            CellBehaviour cell = Instantiate(CellBehaviourPrefab);

            cell.transform.position = new Vector3(CellSize * i, 0, -CellSize * j);
            cell.gameObject.name    = string.Format("Cell {0} {1}", i, j);
            cell.transform.parent   = transform;
            m_Cells[i, j]           = cell;

            return(cell);
        }
예제 #3
0
        public override bool Equals(object other)
        {
            CellBehaviour cell = (CellBehaviour)other;

            if (cell == null)
            {
                return(false);
            }

            return(GetCellData().RootCell.Equals(cell.GetCellData().RootCell));
        }
예제 #4
0
        public override void OnInspectorGUI()
        {
            base.OnInspectorGUI();

            CellBehaviour curCell = (CellBehaviour)target;

            //Цвет кнопки
            GUI.backgroundColor = CellBehaviour.LINK_MODE ? m_EditModeColor : m_NormalColor;
            if (GUILayout.Button(LinkButtonName()))
            {
                //Вход/выход в режим редактирования
                CellBehaviour.EDIT_MODE = !CellBehaviour.EDIT_MODE;
                CellBehaviour.LINK_MODE = !CellBehaviour.LINK_MODE;

                //Если включен режим редактирования
                if (CellBehaviour.EDIT_MODE)
                {
                    //Подписаться на событие выделения ячейки
                    curCell.OnCellSelected = LinkCell;
                }
            }

            //Цвет кнопки
            GUI.backgroundColor = CellBehaviour.UNLINK_MODE ? m_EditModeColor : m_NormalColor;
            if (GUILayout.Button(UnlinkButtonName()))
            {
                //Вход/выход в режим редактирования
                CellBehaviour.EDIT_MODE   = !CellBehaviour.EDIT_MODE;
                CellBehaviour.UNLINK_MODE = !CellBehaviour.UNLINK_MODE;

                //Если включен режим редактирования
                if (CellBehaviour.EDIT_MODE)
                {
                    //Подписаться на событие выделения ячейки
                    curCell.OnCellSelected = UnlinkCell;
                }
            }

            GUI.backgroundColor = m_NormalColor;
            if (CanMoveHigher(curCell) && GUILayout.Button("Move Higher"))
            {
                GridController gridController = FindObjectOfType <GridController>();

                curCell.MoveCellHigher(gridController.VerticalStep);
            }

            if (CanMoveLower(curCell) && GUILayout.Button("Move Lower"))
            {
                GridController gridController = FindObjectOfType <GridController>();

                curCell.MoveCellLower(gridController.VerticalStep);
            }
        }
예제 #5
0
        /// <summary>
        /// Создать связь с ячейкой
        /// </summary>
        /// <param name="linkedCell">Связаная ячейка</param>
        /// <param name="addCellToConnection">Добавить ячейку в связи (редактор) <c>true</c>,
        /// иначе не добавлять ячейку в связи (загрущка)</param>
        public void LinkCell(CellBehaviour linkedCell, bool addCellToConnection = true)
        {
            //Определить тип горизонтального направления к ячейке по вектору направления
            Vector3 dirToLinkedCell = (transform.position - linkedCell.transform.position).normalized;

            GridTools.HorizontalDirections hDir = GridTools.GetHorizontalDirectionByVector(dirToLinkedCell);

            CreateLink(hDir, linkedCell.GetCellData().RootCell, addCellToConnection);

            //Обновить высоту всем соединениям конкретной ячейки
            UpdateVerticalDirectionForConnections(true);
        }
예제 #6
0
        /// <summary>
        /// Задать высоту соединения с конкретной ячейкой
        /// </summary>
        void SetVerticalDirectionToLinkedCell(CellBehaviour linkedCellBehaviour)
        {
            //Направление к ячейке
            Vector3 dirToLinkedCell = (transform.position - linkedCellBehaviour.transform.position).normalized;

            //Направление по вертикали и по горизонтали
            GridTools.HorizontalDirections hDir = GridTools.GetHorizontalDirectionByVector(dirToLinkedCell);
            GridTools.VerticalDirections   vDir = GridTools.GetVerticalDirectionByVector(dirToLinkedCell);

            //Изменить состояние направления соединения
            ConnectionList[(int)hDir].SetVerticaDirection(vDir);
        }
예제 #7
0
        void UnlinkCell(CellBehaviour linkedCell)
        {
            CellBehaviour curCell = (CellBehaviour)target;

            if (!curCell.GetCellData().RootCell.Equals(linkedCell.GetCellData().RootCell) &&    //Если хотим отвязать эту же ячейку
                curCell.GetCellData().LinkedCells.Contains(linkedCell.GetCellData().RootCell))  //Если эта ячейка связана
            {
                //Отвязать текущую ячейку от выбранной
                curCell.UnlinkCell(linkedCell);

                //Отвязать выбраную ячейку от текущей
                linkedCell.UnlinkCell(curCell);
            }
        }
예제 #8
0
        void LinkCell(CellBehaviour linkedCell)
        {
            CellBehaviour curCell = (CellBehaviour)target;

            if (!curCell.GetCellData().RootCell.Equals(linkedCell.GetCellData().RootCell) &&    //Если хотим привязать эту же ячейку
                !curCell.GetCellData().LinkedCells.Contains(linkedCell.GetCellData().RootCell)) //Если эта ячейка уже привязана
            {
                //Связать текущую ячейку с выбранной
                curCell.LinkCell(linkedCell);

                //Связать выбраную ячейку с текущей
                linkedCell.LinkCell(curCell);
            }
        }
예제 #9
0
        public void CreateDefaultGrid()
        {
            m_Cells = new CellBehaviour[GridWidth, GridHeight];

            for (int i = 0; i < GridWidth; i++)
            {
                for (int j = 0; j < GridHeight; j++)
                {
                    CellBehaviour cell = CreateCell(i, j);
                    cell.SetCellData(new CellData(new Cell(i, j)));
                    cell.UpdateEnviroment();
                }
            }
        }
예제 #10
0
        public void LoadGridData()
        {
            GridDataController dataController = GetComponent <GridDataController>();

            GridDataController.SavedData data = dataController.GetData();
            m_Cells = new CellBehaviour[data.GridWidth, data.GridHeight];

            //Создать ячейки
            for (int i = 0; i < data.CellsData.Count; i++)
            {
                CellData cellData     = data.CellsData[i];
                Cell     rootCellData = cellData.RootCell;

                CellBehaviour cell = CreateCell(rootCellData.X, rootCellData.Y);
                cell.SetCellData(cellData);

                //Установка ячейки на уровень
                Vector3 pos = cell.transform.position;
                pos.y = cellData.VerticalLevel * VerticalStep;
                cell.transform.position = pos;
            }

            //Создать связи между ячейками
            for (int i = 0; i < data.GridWidth; i++)
            {
                for (int j = 0; j < data.GridHeight; j++)
                {
                    //Если у ячейки есть связи
                    CellData cellData = m_Cells[i, j].GetCellData();
                    if (cellData.LinkedCells.Count > 0)
                    {
                        for (int index = 0; index < cellData.LinkedCells.Count; index++)
                        {
                            //Координаты связанной ячейки
                            int x = cellData.LinkedCells[index].X;
                            int y = cellData.LinkedCells[index].Y;

                            //Связать ячейки
                            m_Cells[i, j].LinkCell(m_Cells[x, y], false);
                        }

                        //Обновить вертикальное состояние связей для ячейки
                        m_Cells[i, j].UpdateVerticalDirectionForConnections(false);
                    }
                }
            }

            UpdateEnviroment();
        }
예제 #11
0
        void OnEnable()
        {
            //Подписаться на событие входа/выхода из режима редактирования
            CellBehaviour source = (CellBehaviour)target;

            if (source.OnEditModeChanged == null)
            {
                source.OnEditModeChanged = EditModeChangedHandler;
            }

            GridController gridController = FindObjectOfType <GridController>();

            m_MaxHigh      = gridController.VerticalStep * ((gridController.VericalLevels - 1) / 2);
            m_MinHight     = -m_MaxHigh;
            m_VerticalStep = gridController.VerticalStep;
        }
예제 #12
0
        void EditModeChangedHandler(bool isEditMode)
        {
            CellBehaviour  curCell        = (CellBehaviour)target;
            GridController gridController = FindObjectOfType <GridController>();

            if (!isEditMode) //Если режим редактрирования выключен
            {
                //Выключеть текущий режим
                CellBehaviour.LINK_MODE   = false;
                CellBehaviour.UNLINK_MODE = false;

                //Обновить цвета всех ячеек до изначального
                gridController.ResetColor();
            }
            else
            {
                //Цвет текущей ячейки
                curCell.ColorizeCell(gridController.MaterialSelectedCell);
            }
        }
예제 #13
0
        /// <summary>
        /// Обновить высоту всем соединениям конкретной ячейки
        /// </summary>
        /// <param name="updateConnectionForLinkedCell">Обновить соеинение связанным ячейкам (редактор) если <c>true</c>,
        /// иначе не обновлять состояние связанным ячейкам (загрузка).</param>
        public void UpdateVerticalDirectionForConnections(bool updateConnectionForLinkedCell)
        {
            GridController gridController = FindObjectOfType <GridController>();

            //Все связанные ячейки
            foreach (Cell cData in m_CellData.LinkedCells)
            {
                CellBehaviour linkedCellBehaviour = gridController.GetCell(cData.X, cData.Y);

                //Обновить состояние соединения
                if (linkedCellBehaviour != null)
                {
                    SetVerticalDirectionToLinkedCell(linkedCellBehaviour);
                }

                //Обновить высоту соединения соседней ячейки (редактор)
                if (updateConnectionForLinkedCell)
                {
                    linkedCellBehaviour.UpdateVerticalDirectionForConnections(false);
                }
            }
        }
예제 #14
0
        void OnSceneGUI()
        {
            //Отслеживание состояния изменения редима редактирования для текущей ячейки
            if (CellBehaviour.EDIT_MODE.Equals(!CellBehaviour.PREV_EDIT_MODE))
            {
                CellBehaviour.PREV_EDIT_MODE = CellBehaviour.EDIT_MODE;

                CellBehaviour curCell = (CellBehaviour)target;
                curCell.OnEditModeChanged(CellBehaviour.EDIT_MODE);
            }

            //Выделение ячейки на которую наведен указатель
            if (CellBehaviour.EDIT_MODE)
            {
                CellBehaviour targetCell = GetCell();
                if (targetCell != null)
                {
                    CellBehaviour curCell = (CellBehaviour)target;

                    //Если выделеная ячейка не текущая
                    if (!curCell.Equals(targetCell))
                    {
                        GridController gridController = FindObjectOfType <GridController>();

                        //Восстановить цвет предыдущей ячейке
                        if (CellBehaviour.PrevTargetCell != null)
                        {
                            CellBehaviour.PrevTargetCell.ColorizeCell(gridController.MaterialNormalCell);
                        }

                        //Предыдущая ячейка равняеться текущей
                        CellBehaviour.PrevTargetCell = targetCell;

                        //Покрасить текущю ячейку
                        if (CellIsAvailable(curCell.GetCellData().RootCell, targetCell.GetCellData().RootCell))
                        {
                            targetCell.ColorizeCell(gridController.MaterialTargetCell);
                        }
                        else
                        {
                            targetCell.ColorizeCell(gridController.MaterialUnavailableCell);
                        }

                        //Нарисовать линию к выбранной ячейке
                        Handles.DrawLine(curCell.transform.position, targetCell.transform.position);
                    }
                }
            }

            //Связка ячеек
            CellBehaviour linkedCell = GetCellByClick();

            if (linkedCell != null)
            {
                CellBehaviour curCell = (CellBehaviour)target;

                if (CellIsAvailable(curCell.GetCellData().RootCell, linkedCell.GetCellData().RootCell))
                {
                    curCell.OnCellSelected(linkedCell);
                }
            }
        }
예제 #15
0
 bool CanMoveLower(CellBehaviour curCell)
 {
     return(curCell.transform.position.y >= m_MinHight + m_VerticalStep);
 }
예제 #16
0
 bool CanMoveHigher(CellBehaviour curCell)
 {
     return(curCell.transform.position.y <= m_MaxHigh - m_VerticalStep);
 }