/// <summary>
        /// 유닛을 실제로 이동 시키고 각종 초기화를 수행한다.
        /// </summary>
        /// <param name="_path"></param>
        /// <returns></returns>
        IEnumerator MoveCoroutine(HashSet <Vector3Int> _path, Vector3Int _targetPosition)
        {
            SquareTile item = Map.instance.m_TilemapHighlight.m_Tilemap.GetTile <SquareTile>(m_Position);

            item.m_State = null;
            item.m_State = new TileStateNormal(m_Position);
            SquareTile normalTile = SquareTileFactory.CreateNormal(m_Position);

            Map.instance.m_TilemapHighlight.m_Tilemap.SetTile(normalTile.m_Position, normalTile);

            foreach (Vector3Int point in _path)
            {
                Vector3 pos = m_SetCenterPosition.GetWorldPosition(point);
                transform.DOMove(pos, 1f);
                yield return(new WaitForSeconds(1f));

                if (point == _targetPosition)
                {
                    break;
                }
            }

            // 초기화
            SetToIdle();

            SetPosition(_targetPosition, true);

            InitTiles();
        }
        /// <summary>
        /// 공격 가능한 타일들을 모두 삭제한다.
        /// </summary>
        private void ClearAttackables()
        {
            if (m_AttackableTiles == null)
            {
                return;
            }

            if (m_AttackableTiles.Count == 0)
            {
                return;
            }

            Dictionary <Vector3Int, float> costs = new Dictionary <Vector3Int, float>();

            foreach (var item in m_AttackableTiles)
            {
                //if ( item.m_State.m_State != eTileType.Attackable )
                //{
                //    continue;
                //}

                item.m_State = null;
                item.m_State = new TileStateUnitPlaced(item.m_Position);
                SquareTile unitTile = SquareTileFactory.CreateUnitPlaced(item.m_Position);

                m_Tilemap.SetTile(unitTile.m_Position, unitTile);

                costs.Add(item.m_Position, 0f);
            }

            m_Grid.UpdateGrid(costs);
        }
Beispiel #3
0
        /// <summary>
        /// 해당 위치에 타일을 삭제한다.
        /// </summary>
        /// <param name="_position"></param>
        public void DeleteTile(Vector3Int _position)
        {
            SquareTile tile = m_Tilemap.GetTile <SquareTile>(_position);

            if (tile == null)
            {
                return;
            }

            // 이동 가능한 타일 / 유닛이 위치한 타일 / 이동 경로 타일 일 때는 삭제할 필요가 없다.
            if (tile.m_State.m_State == eTileType.Movable)
            {
                return;
            }


            // 그 외의 타일일 경우에는 일반 타일로 교체한다.
            tile.m_State = null;
            tile.m_State = new TileStateNormal(tile.m_Position);
            SquareTile normalTile = SquareTileFactory.CreateNormal(tile.m_Position);

            m_Tilemap.SetTile(normalTile.m_Position, normalTile);

            m_TilemapPathFind.m_Grid.UpdateTile(_position, 0f);
        }
        /// <summary>
        /// 이동 가능한 영역의 타일들을 모두 삭제한다.
        /// </summary>
        public void ClearMovableTiles()
        {
            if (m_MovableTiles == null)
            {
                return;
            }

            if (m_MovableTiles.Count == 0)
            {
                return;
            }

            Dictionary <Vector3Int, float> costs = new Dictionary <Vector3Int, float>();

            foreach (var item in m_MovableTiles)
            {
                if (item.m_State.m_State != eTileType.Movable)
                {
                    continue;
                }

                item.m_State = null;
                item.m_State = new TileStateNormal(item.m_Position);
                SquareTile normalTile = SquareTileFactory.CreateNormal(item.m_Position);

                m_Tilemap.SetTile(normalTile.m_Position, normalTile);

                costs.Add(item.m_Position, 0f);
            }

            m_Grid.UpdateGrid(costs);
        }
        private void InitTiles()
        {
            SquareTile tile = ScriptableObject.CreateInstance <SquareTile>();

            tile.m_Position = m_Position;
            tile.m_State    = new TileStateNormal(tile.m_Position);
            m_CurrentTile   = SquareTileFactory.CreateNormal(tile.m_Position);
            Map.instance.m_TilemapHighlight.m_Tilemap.SetTile(m_Position, m_CurrentTile);

            Map.instance.m_TilemapController.ResetAllTiles();
            Map.instance.m_TilemapController.SetAllUnitPlacedTiles();
        }
Beispiel #6
0
        /// <summary>
        /// 유닛이 위치한 타일을 제외하고 모든 타일들을 모두 지운다.
        /// </summary>
        public void ResetAllTiles()
        {
            Dictionary <Vector3Int, float> costs = new Dictionary <Vector3Int, float>();

            for (int x = m_Bounds.xMin; x < m_Bounds.xMax; x++)
            {
                for (int y = m_Bounds.yMin; y < m_Bounds.yMax; y++)
                {
                    Vector3Int pos = new Vector3Int(x, y, 0);

                    SquareTile tile = m_Tilemap.GetTile <SquareTile>(pos);

                    // 유닛이 위치한 타일은 초기화 할 필요 없다.
                    //if ( tile.m_State.m_State == eTileType.UnitPlaced )
                    //{
                    //    //tile.m_Cost = 0;
                    //    //tile.m_Distance = 0;
                    //    //m_Tilemap.SetTile( tile.m_Position, tile );
                    //    continue;
                    //}
                    // 타일 위에 유닛이 없으면 일반 타일로 초기화시킨다.
                    //else
                    {
                        tile.m_State = null;
                        tile.m_State = new TileStateNormal(tile.m_Position);
                        SquareTile normalTile = SquareTileFactory.CreateNormal(tile.m_Position);

                        m_Tilemap.SetTile(normalTile.m_Position, normalTile);

                        costs.Add(tile.m_Position, 0f);
                    }
                }
            }
            // 테스트 코드
            //for ( int x = m_Bounds.xMin; x < m_Bounds.xMax; x++ )
            //{
            //    for ( int y = m_Bounds.yMin; y < m_Bounds.yMax; y++ )
            //    {
            //        Vector3Int pos = new Vector3Int( x, y, 0 );

            //        SquareTile tile = m_Tilemap.GetTile<SquareTile>( pos );
            //        if ( tile.m_Distance != 0 )
            //        {
            //            Debug.Log( pos );
            //        }
            //    }
            //}

            m_TilemapPathFind.m_Grid.UpdateGrid(costs);
        }
        /// <summary>
        /// 해당 위치를 기준으로 공격 가능한 타일들을 표시한다.
        /// </summary>
        /// <param name="_unit"></param>
        /// <param name="_start"></param>
        public void DrawAttackableRange(Unit _unit, SquareTile _start)
        {
            m_AttackableTiles = SearchToAttack(_start, _unit.m_Stat.m_AttackRange);

            if (m_AttackableTiles.Count == 0)
            {
                return;
            }

            Dictionary <Vector3Int, float> costs = new Dictionary <Vector3Int, float>();

            HashSet <Vector3Int> obstacles = Map.instance.m_TilemapObstacle.GetObstacleTiles();

            foreach (var tile in m_AttackableTiles)
            {
                bool isObstacle = false;

                // 장애물이 있을 경우, 장애물 타일로 변경
                foreach (var point in obstacles)
                {
                    if (point == tile.m_Position)
                    {
                        tile.m_State = null;
                        tile.m_State = new TileStateObstacle(tile.m_Position);
                        SquareTile obstacle = SquareTileFactory.CreateObstacle(tile.m_Position);

                        m_Tilemap.SetTile(tile.m_Position, obstacle);

                        costs.Add(tile.m_Position, 0f);

                        isObstacle = true;
                        break;
                    }
                }

                // 장애물이 아니고 타일 위에 적 캐릭터가 있으면 공격 가능한 타일로 설정한다.
                if (isObstacle == false && tile.m_Unit.m_Type == eCampType.Enemies)
                {
                    tile.m_State = null;
                    tile.m_State = new TileStateAttackable(tile.m_Position);
                    SquareTile attackTile = SquareTileFactory.CreateAttackable(tile.m_Position);

                    m_Tilemap.SetTile(attackTile.m_Position, attackTile);

                    costs.Add(tile.m_Position, 1f);
                }
            }

            m_Grid.UpdateGrid(costs);
        }
        /// <summary>
        /// 해당 위치를 기준으로 이동 가능한 타일들을 표시한다.
        /// </summary>
        /// <param name="_start"></param>
        public void DrawMovableRange(Unit _unit, SquareTile _start)
        {
            m_MovableTiles = SearchToMove(_start, _unit.m_Stat.m_MoveRange);

            if (m_MovableTiles.Count == 0)
            {
                return;
            }

            Dictionary <Vector3Int, float> costs = new Dictionary <Vector3Int, float>();

            HashSet <Vector3Int> obstacles = Map.instance.m_TilemapObstacle.GetObstacleTiles();

            foreach (var tile in m_MovableTiles)
            {
                bool isObstacle = false;

                // 장애물이 있을 경우, 장애물 타일로 변경
                foreach (var point in obstacles)
                {
                    if (point == tile.m_Position)
                    {
                        tile.m_State = null;
                        tile.m_State = new TileStateObstacle(tile.m_Position);
                        SquareTile obstacle = SquareTileFactory.CreateObstacle(tile.m_Position);

                        m_Tilemap.SetTile(obstacle.m_Position, obstacle);

                        costs.Add(obstacle.m_Position, 0f);

                        isObstacle = true;
                        break;
                    }
                }

                // 장애물이 아닐 경우,
                if (isObstacle == false)
                {
                    tile.m_State = null;
                    tile.m_State = new TileStateMovable(tile.m_Position);
                    SquareTile moveTile = SquareTileFactory.CreateMovable(tile.m_Position);

                    m_Tilemap.SetTile(moveTile.m_Position, moveTile);

                    costs.Add(tile.m_Position, 1f);
                }
            }

            m_Grid.UpdateGrid(costs);
        }
        /// <summary>
        /// 타일맵을 격자 형태의 타일들로 설정한다.
        /// </summary>
        private void CreateGridTiles()
        {
            for (int x = m_Bounds.xMin; x < m_Bounds.xMax; x++)
            {
                for (int y = m_Bounds.yMin; y < m_Bounds.yMax; y++)
                {
                    Vector3Int pos = new Vector3Int(x, y, 0);

                    SquareTile tile = ScriptableObject.CreateInstance <SquareTile>();
                    tile.m_Position = pos;
                    tile.m_State    = new TileStateOutline(tile.m_Position);
                    SquareTile gridTile = SquareTileFactory.CreateGrid(tile.m_Position);

                    m_Tilemap.SetTile(gridTile.m_Position, gridTile);
                }
            }
        }
Beispiel #10
0
        /// <summary>
        /// 지정한 위치의 타일을 유닛이 위치한 타일로 설정한다.
        /// </summary>
        /// <param name="_position"></param>
        public void SetTileAsUnitPlaced(Vector3Int _position)
        {
            SquareTile tile = ScriptableObject.CreateInstance <SquareTile>();

            tile.m_Position = _position;
            tile.m_Cost     = 0f;
            tile.m_State    = null;
            tile.m_State    = new TileStateUnitPlaced(tile.m_Position);
            SquareTile unitTile = SquareTileFactory.CreateUnitPlaced(tile.m_Position);

            unitTile.m_Unit = UnitManager.GetUnitAt(_position);
            if (unitTile.m_Unit == null)
            {
                Debug.LogError("unitTile.m_Unit == null");
                return;
            }

            m_Tilemap.SetTile(unitTile.m_Position, unitTile);
        }
Beispiel #11
0
        /// <summary>
        /// Tilemap에 SquareTile들로 설정한다.
        /// </summary>
        private void CreateTilesToNormal()
        {
            // Tilemap 크기에 맞추어 SquareTile들을 생성한다.
            for (int x = m_Bounds.xMin; x < m_Bounds.xMax; x++)
            {
                for (int y = m_Bounds.yMin; y < m_Bounds.yMax; y++)
                {
                    Vector3Int current = new Vector3Int(x, y, 0);

                    SquareTile normal = ScriptableObject.CreateInstance <SquareTile>();
                    normal.m_Position = new Vector3Int(x, y, 0);
                    normal.m_Cost     = 1f;
                    normal.m_State    = new TileStateNormal(normal.m_Position);
                    SquareTile tile = SquareTileFactory.CreateNormal(normal.m_Position);

                    m_Tilemap.SetTile(current, tile);
                }
            }
        }
Beispiel #12
0
        public void ResetAllExceptMoveTiles()
        {
            Dictionary <Vector3Int, float> costs = new Dictionary <Vector3Int, float>();

            for (int x = m_Bounds.xMin; x < m_Bounds.xMax; x++)
            {
                for (int y = m_Bounds.yMin; y < m_Bounds.yMax; y++)
                {
                    Vector3Int pos = new Vector3Int(x, y, 0);

                    SquareTile tile = m_Tilemap.GetTile <SquareTile>(pos);

                    //if ( tile.m_State.m_State == eTileType.UnitPlaced )
                    //{
                    //    continue;
                    //}
                    /*else */ if (tile.m_State.m_State == eTileType.Movable)
                    {
                        continue;
                    }
                    //else if ( tile.m_State.m_State == eTileType.Path )
                    //{
                    //    continue;
                    //}
                    //else if ( tile.m_State.m_State == eTileType.Attackable )
                    //{
                    //    continue;
                    //}
                    else
                    {
                        tile.m_State = null;
                        tile.m_State = new TileStateNormal(tile.m_Position);
                        SquareTile normalTile = SquareTileFactory.CreateNormal(tile.m_Position);

                        m_Tilemap.SetTile(normalTile.m_Position, normalTile);

                        costs.Add(tile.m_Position, 0f);
                    }
                }
            }

            m_TilemapPathFind.m_Grid.UpdateGrid(costs);
        }
        public override void OnClicked()
        {
            base.OnClicked();

            // 선택된 타일로 설정
            SquareTile tile = SquareTileFactory.CreateSelected(m_Position);

            Map.instance.m_TilemapHighlight.m_Tilemap.SetTile(m_Position, tile);

            // 이동 준비 상태의 플레이어가 있으면 대기 상태로 되돌린다
            UnitKnight knight = UnitManager.GetReadyToMovePlayer();

            if (knight != null)
            {
                knight.SetToIdle();
            }

            Map.instance.m_TilemapController.ResetAllTiles();
            Map.instance.m_TilemapController.SetAllUnitPlacedTiles();
        }
        /// <summary>
        /// 이동 경로를 모두 삭제한다.
        /// </summary>
        private void ClearPath()
        {
            if (m_Paths == null)
            {
                return;
            }
            if (m_Paths.Count == 0)
            {
                return;
            }

            foreach (Vector3Int point in m_Paths)
            {
                SquareTile tile = m_Tilemap.GetTile <SquareTile>(point);
                tile.m_State = null;
                tile.m_State = new TileStateMovable(tile.m_Position);
                SquareTile moveTile = SquareTileFactory.CreateMovable(tile.m_Position);

                m_Tilemap.SetTile(moveTile.m_Position, moveTile);
            }

            m_Paths.Clear();
        }
        /// <summary>
        /// 이동 경로를 설정한다.
        /// </summary>
        /// <param name="_from"></param>
        /// <param name="_to"></param>
        public void SetPathFindGrid(Vector3Int _from, Vector3Int _to)
        {
            // 초기화 필수
            ClearPath();

            // get path
            // path will either be a list of Points (x, y), or an empty list if no path is found.
            m_Paths = PathFind.FindPath(
                m_Grid,
                _from,
                _to,
                ePathFindDistanceType.Manhattan);

            foreach (Vector3Int point in m_Paths)
            {
                SquareTile tile = m_Tilemap.GetTile <SquareTile>(point);

                tile.m_State = null;
                tile.m_State = new TileStatePath(tile.m_Position);
                SquareTile pathTile = SquareTileFactory.CreatePath(tile.m_Position);

                m_Tilemap.SetTile(pathTile.m_Position, pathTile);
            }
        }