Beispiel #1
0
        public void Sin(int _appearNum, PlayersEnemyData _enemyData, Vector2 _appearPos,
                        Vector2 _posInterval)
        {
            int   appearCount = 0;
            float appearSpace = -20;
            float appearPosX  = -90;
            float appearPosY  = 40;

            if (_enemyData.PlayerType.Equals("Enemy2"))
            {
                appearPosX = -2.0f;
            }

            for (int i = 0; i < _enemyData.SinEnemys.Length; i++)
            {
                if (appearCount >= _appearNum)
                {
                    break;
                }

                if (!_enemyData.SinEnemys[i].activeSelf)
                {
                    // 起点に設置
                    _enemyData.SinEnemys[i].transform.position =
                        new Vector3(appearPosX + appearCount * appearSpace, appearPosY, AppearZPos);
                    _enemyData.SinEnemys[i].SetActive(true);
                    appearCount++;

                    // 次の起点の間隔をあける
                    _appearPos += _posInterval;
                }
            }
        }
Beispiel #2
0
        public void Coaster(int _appearNum, PlayersEnemyData _enemyData, float _radius, Vector2 _appearPos, Vector2 _posInterval)
        {
            int   appearCount = 0;
            float inter       = 180.0f;

            for (int i = 0; i < _enemyData.CoasterEnemys.Length; i++)
            {
                if (appearCount >= _appearNum)
                {
                    break;
                }

                if (!_enemyData.CoasterEnemys[i].activeSelf)
                {
                    // 起点に設置
                    _enemyData.CoasterEnemys[i].transform.position = new Vector3(_appearPos.x + appearCount * _posInterval.x, _appearPos.y, AppearZPos);
                    _enemyData.CoasterEnemys[i].GetComponent <CircleEnemy>().CenterPos = _appearPos;
                    _enemyData.CoasterEnemys[i].SetActive(true);
                    appearCount++;

                    // 次の起点の間隔をあける
                    _appearPos += _posInterval * Time.deltaTime;
                    inter      += 1.0f;
                }
            }
        }
Beispiel #3
0
        public void Stay(int _appearNum, PlayersEnemyData _enemyData, Vector2 _appearPos,
                         Vector2 _posInterval)
        {
            int   appearCount = 0;
            float appearSpace = System.Math.Abs(_enemyData.LeftPosX - _enemyData.RightPosX) / (_appearNum + 1);
            //float appearRightPosX = _enemyData.RightPosX - appearSpace;
            float appearLeftPosX = _enemyData.LeftPosX + appearSpace;

            for (int i = 0; i < _enemyData.StayEnemys.Length; i++)
            {
                if (appearCount >= _appearNum)
                {
                    break;
                }

                if (!_enemyData.StayEnemys[i].activeSelf)
                {
                    // 起点に設置
                    _enemyData.StayEnemys[i].transform.position =
                        new Vector3(appearLeftPosX + appearCount * appearSpace, _enemyData.EnemyStartPos.y, _enemyData.EnemyStartPos.z);
                    _enemyData.StayEnemys[i].SetActive(true);
                    appearCount++;

                    // 次の起点の間隔をあける
                    _appearPos += _posInterval;
                }
            }
        }
Beispiel #4
0
        public void ToRightSide(int _appearNum, PlayersEnemyData _enemyData, Vector2 _appearPos,
                                Vector2 _posInterval)
        {
            int appearCount = 0;

            for (int i = 0; i < _enemyData.ToRightSideEnemys.Length; i++)
            {
                float rand = Random.Range(0, 40);
                if (appearCount >= _appearNum)
                {
                    break;
                }

                if (!_enemyData.ToRightSideEnemys[i].activeSelf)
                {
                    // 起点に設置
                    _enemyData.ToRightSideEnemys[i].transform.position =
                        new Vector3(_enemyData.LeftPosX - appearCount * 10, rand, _enemyData.EnemyStartPos.z);
                    _enemyData.ToRightSideEnemys[i].SetActive(true);
                    appearCount++;

                    // 次の起点の間隔をあける
                    _appearPos += _posInterval;
                }
            }
        }
Beispiel #5
0
        private void SetEnemy(PlayersEnemyData _enemyData)
        {
            for (int i = 0; i < _enemyData.PoolEnemy; i++)
            {
                _enemyData.StraightEnemys[i]     = this.CreateEnemy(this.straightEnemy);
                _enemyData.StraightEnemys[i].tag = _enemyData.PlayerType;

                _enemyData.ToLeftSideEnemys[i]     = this.CreateEnemy(this.toLeftSideEnemy);
                _enemyData.ToLeftSideEnemys[i].tag = _enemyData.PlayerType;

                _enemyData.ToRightSideEnemys[i]     = this.CreateEnemy(this.toRightSideEnemy);
                _enemyData.ToRightSideEnemys[i].tag = _enemyData.PlayerType;

                _enemyData.CircleEnemys[i]     = this.CreateEnemy(this.circleEnemy);
                _enemyData.CircleEnemys[i].tag = _enemyData.PlayerType;

                _enemyData.CoasterEnemys[i]     = this.CreateEnemy(this.coasterEnemy);
                _enemyData.CoasterEnemys[i].tag = _enemyData.PlayerType;

                _enemyData.QuadraticEnemys[i]     = this.CreateEnemy(this.quadraticEnemy);
                _enemyData.QuadraticEnemys[i].tag = _enemyData.PlayerType;

                _enemyData.StayEnemys[i]     = this.CreateEnemy(this.stayEnemy);
                _enemyData.StayEnemys[i].tag = _enemyData.PlayerType;

                _enemyData.SinEnemys[i]     = this.CreateEnemy(this.sinEnemy);
                _enemyData.SinEnemys[i].tag = _enemyData.PlayerType;
            }

            _enemyData.BeeEnemy     = this.CreateEnemy(this.beeEnemy);
            _enemyData.BeeEnemy.tag = _enemyData.PlayerType;
        }
Beispiel #6
0
 private void Awake()
 {
     this.Enemy1Data = new PlayersEnemyData("Enemy1", Enemy1Patterns, this.poolEnemy);
     this.Enemy2Data = new PlayersEnemyData("Enemy2", Enemy2Patterns, this.poolEnemy);
     this.SetEnemy(this.Enemy1Data);
     this.SetEnemy(this.Enemy2Data);
     this.Enemy1Data.EnemyAppearPass = this.interval;
     this.Enemy2Data.EnemyAppearPass = this.interval;
 }
Beispiel #7
0
        /*
         * public void Appear(int _appearNum, GameObject[] _enemyPool, Vector2 _appearPos, Vector2 _posInterval)
         * {
         *  int appearCount = 0;
         *
         *  for (int i = 0; i < _enemyPool.Length; i ++)
         *  {
         *      if (appearCount >= _appearNum) { break; }
         *
         *      if (_enemyPool[i].activeSelf)
         *      {
         *          // 起点に設置
         *          _enemyPool[i].transform.position = new Vector3 (_appearPos.x, _appearPos.y, AppearZPos);
         *          _enemyPool[i].SetActive (true);
         *          appearCount++;
         *
         *          // 次の起点の間隔をあける
         *          _appearPos += _posInterval;
         *      }
         *  }
         * }
         */

        /// <summary>
        ///
        /// </summary>
        /// <param name="_appearNum">敵機の登場数</param>
        /// <param name="_appearPos">登場する座標</param>
        /// <param name="_posInterval">登場する座標の間隔</param>
        public void Circle(int _appearNum, PlayersEnemyData _enemyData, Vector2 _appearPos, Vector2 _posInterval)
        {
            int appearCount = 0;

            for (int i = 0; i < _enemyData.CircleEnemys.Length; i++)
            {
                if (appearCount >= _appearNum)
                {
                    break;
                }

                if (!_enemyData.CircleEnemys[i].activeSelf)
                {
                    // 起点に設置
                    _enemyData.CircleEnemys[i].transform.position = new Vector3(_enemyData.EnemyStartPos.x, _enemyData.EnemyStartPos.y, AppearZPos);
                    _enemyData.CircleEnemys[i].GetComponent <CircleEnemy>().CenterPos = this.transform.position;
                    _enemyData.CircleEnemys[i].SetActive(true);
                    appearCount++;

                    // 次の起点の間隔をあける
                    _appearPos += _posInterval;
                }
            }
        }
Beispiel #8
0
 public void Bee(PlayersEnemyData _enemyData)
 {
     _enemyData.BeeEnemy.transform.position = _enemyData.EnemyStartPos;
     _enemyData.BeeEnemy.SetActive(true);
 }
Beispiel #9
0
        public void EnemyAppear(float _nowPass, PlayersEnemyData _enemyData)
        {
            if (_nowPass >= _enemyData.EnemyAppearPass)
            {
                if (_enemyData.EnemyCount < _enemyData.EnemyPatterns.Length)
                {
                    switch (_enemyData.EnemyPatterns[_enemyData.EnemyCount].ToString())
                    {
                    case "StraightHorizontal":
                        StraightHorizontal(
                            7,
                            _enemyData,
                            this.enemyManagerAppearParam.StraightHorizontalPos,
                            this.enemyManagerAppearParam.StraightHorizontalPosInterval);
                        break;

                    case "StraightVertical":
                        StraightVertical();
                        break;

                    case "Straights":
                        Straights(
                            10,
                            _enemyData,
                            this.enemyManagerAppearParam.StraightHorizontalPos,
                            this.enemyManagerAppearParam.StraightHorizontalPosInterval);
                        break;

                    case "ToLeftSide":
                        ToLeftSide(
                            10,
                            _enemyData,
                            this.enemyManagerAppearParam.StraightHorizontalPos,
                            this.enemyManagerAppearParam.StraightHorizontalPosInterval);
                        break;

                    case "ToRightSide":
                        ToRightSide(
                            10,
                            _enemyData,
                            this.enemyManagerAppearParam.StraightHorizontalPos,
                            this.enemyManagerAppearParam.StraightHorizontalPosInterval);
                        break;

                    case "Quadratic":
                        Quadratic(
                            3,
                            _enemyData,
                            this.enemyManagerAppearParam.QuadraticPos,
                            this.enemyManagerAppearParam.QuadraticPosInterval);
                        break;

                    case "Circle":
                        Circle(
                            1,
                            _enemyData,
                            this.enemyManagerAppearParam.CirclePos,
                            this.enemyManagerAppearParam.CirclePosInterval);
                        break;

                    case "Coaster":
                        /*
                         * Coaster(
                         *      20,
                         *      _enemyData,
                         *      this.enemyManagerAppearParam.Radius,
                         *      this.enemyManagerAppearParam.CoasterPos,
                         *      this.enemyManagerAppearParam.CoasterPosInterval);
                         */

                        Quadratic(
                            10,
                            _enemyData,
                            this.enemyManagerAppearParam.CoasterPos,
                            this.enemyManagerAppearParam.CirclePosInterval);
                        break;
                        break;

                    case "Stay":
                        Stay(
                            5,
                            _enemyData,
                            this.enemyManagerAppearParam.StraightHorizontalPos,
                            this.enemyManagerAppearParam.StraightHorizontalPosInterval);
                        break;

                    case "Sin":
                        Sin(
                            3,
                            _enemyData,
                            this.enemyManagerAppearParam.StraightHorizontalPos,
                            this.enemyManagerAppearParam.StraightHorizontalPosInterval);
                        break;

                    case "Bee":
                        Bee(
                            _enemyData);
                        break;
                    }

                    _enemyData.EnemyCount++;
                    _enemyData.EnemyAppearPass += this.interval;
                }
            }
        }