private IEnumerator SpawnEnemyWaveCoroutine(EnemyWaveData wave)
    {
        currentWaveSpawnEvents.Clear();
        currentWaveSpawnEvents.AddRange(wave.spawnEvents);
        activelySpawning = true;

        while (activelySpawning)
        {
            for (int i = 0; i < currentWaveSpawnEvents.Count - 1; i++)
            {
                SpawnEvent se         = currentWaveSpawnEvents[i];
                float      spawnDelay = Random.Range(se.preSpawnDelayMin, se.preSpawnDelayMax);
                yield return(new WaitForSeconds(spawnDelay));

                Transform spawnLocation = GetSpawnLocationFromSpawnEvent(se);
                SpawnEnemy(se.enemyPrefab, spawnLocation.position);

                // is this the last enemy to spawn in the wave?
                if (currentWaveSpawnEvents.Count > 0 &&
                    currentWaveSpawnEvents.Last() == se)
                {
                    activelySpawning = false;
                }
            }
            activelySpawning = false;
        }
    }
Ejemplo n.º 2
0
    //XML을 읽어서 enemyWaveDatas에 저장한다.
    void LoadEnemyWaveDataFromXML()
    {
        //이미 데이터를 로딩했다면 다시 로딩하지 못하도록 예외처리.
        if (enemyWaveDatas != null && enemyWaveDatas.Count > 0)
        {
            return;
        }

        // XML파일을 읽는다.
        TextAsset xmlText = Resources.Load("EnemyWaveData") as TextAsset;
        // XML 파일을 문서 객체 모델(DOM)로 전환한다.
        XmlDocument xDoc = new XmlDocument();

        xDoc.LoadXml(xmlText.text);
        // XML파일 안에 EnemyWaveData란 XmlNode를 모두 읽어드린다.
        XmlNodeList nodeList = xDoc.DocumentElement.SelectNodes("EnemyWaveData");

        XmlSerializer serializer = new XmlSerializer(typeof(EnemyWaveData));

        // 역질렬화를 통해 EnemyWaveData 구조체로 변경하여 enemyWaveDatas  멤버 필드에 저장한다.
        for (int i = 0; i < nodeList.Count; i++)
        {
            EnemyWaveData enemyWaveData =
                (EnemyWaveData)serializer.Deserialize(new XmlNodeReader(nodeList [i]));
            enemyWaveDatas.Add(enemyWaveData);
        }
    }
Ejemplo n.º 3
0
 // Start is called before the first frame update
 void Start()
 {
     if (Waves.Length > 0)
     {
         currentWave = Waves[0];
     }
 }
    private IEnumerator SpawnAllEnemiesInWave(EnemyWaveData enemyWaveData)
    {
        for (int enemyCount = 0; enemyCount < enemyWaveData.NumberOfEnemies; enemyCount++)
        {
            GameObject enemy;

            switch (enemyWaveData.EnemyData.Shape)
            {
            case "small":
                enemy = enemyPools.transform.Find("Small Enemy Pool").GetComponent <ObjectPool>().GetObject();
                break;

            case "big":
                enemy = enemyPools.transform.Find("Big Enemy Pool").GetComponent <ObjectPool>().GetObject();
                break;

            default:
                enemy = enemyPools.transform.Find("Small Enemy Pool").GetComponent <ObjectPool>().GetObject();
                break;
            }

            enemy.GetComponent <Enemy>().SetEnemyData(enemyWaveData.EnemyData);
            enemy.GetComponent <EnemyPathing>().SetEnemyWaveData(enemyWaveData);
            enemy.GetComponent <EnemyFiring>().SetBulletPools(bulletPools);

            enemy.SetActive(true);

            yield return(new WaitForSeconds(enemyWaveData.TimeBetweenSpawns));
        }
    }
Ejemplo n.º 5
0
 public EnemyWave(EnemyWaveData data)
 {
     this.enemyName      = data.enemyName;
     this.burst          = data.burst;
     this.maxAmount      = data.maxNumber;
     this.initialDelay   = data.initialSpawnTime;
     this.inBetweenDelay = data.interSpawnTime;
 }
Ejemplo n.º 6
0
 public EnemyWave(EnemyWaveData data, int multiplier)
 {
     Count        = data.Count * multiplier;
     Hp           = data.Hp * multiplier;
     CallDown     = data.CallDown * multiplier;
     Damage       = data.Damage * multiplier;
     Speed        = data.Speed * multiplier;
     BulletDamage = data.BulletDamage * multiplier;
 }
Ejemplo n.º 7
0
 public EnemyWaveEngine(Sequencer enemyWaveSequence)
 {
     this.enemyWaveSequence = enemyWaveSequence;
     JSonEnemyWaveData[] jSonEnemyWave = ReadEnemyWaveDataServiceRequest();
     wavesData = new EnemyWaveData[jSonEnemyWave.Length];
     for (int i = 0; i < jSonEnemyWave.Length; i++)
     {
         wavesData[i] = new EnemyWaveData(jSonEnemyWave[i]);
     }
 }
Ejemplo n.º 8
0
 public void Step(ref EnemyWaveData token, int condition)
 {
     if (condition == WaveCondition.Next || condition == WaveCondition.Last)
     {
         OnWaveCompleteEvent();
     }
     else if (condition == WaveCondition.Stop)
     {
         OnLevelCompleteEvent();
     }
 }
Ejemplo n.º 9
0
    void SpawnEnemy(EnemyWaveData enemyData)
    {
        int positionPointer = 1;
        int shiftPosition   = 0;

        // 생성할 위치 값으로 생성할 유닛 수 판단.
        enemyData.amount = positionToAmount[enemyData.spawnPosition];
        // 생성해야하는 숫자만큼 loop
        for (int i = 0; i < enemyData.amount; i++)
        {
            // 생성할 위치 선택.
            while ((positionPointer & enemyData.spawnPosition) < 1)
            {
                shiftPosition++;
                positionPointer = 1 << shiftPosition;
            }
            // 오브젝트 풀에 사용가능한 게임 오브젝트가 있는지 점검.

            GameObject currentSpawnGameObject;
            if (!gameObjectPools[enemyData.type]
                .NextGameObject(out currentSpawnGameObject))
            {
                // 사용가능한 게임 오브젝트가 없다면 생성하여 추가한다.
                currentSpawnGameObject =
                    Instantiate(
                        gameObjectPools[enemyData.type].spawnObj,
                        gameObjectPoolPosition.transform.position,
                        Quaternion.identity) as GameObject;

                currentSpawnGameObject.transform.parent = gameObjectPoolPosition;
                currentSpawnGameObject.name             =
                    enemyData.type + gameObjectPools[enemyData.type].lastIndex;
                gameObjectPools[enemyData.type].AddGameObject(currentSpawnGameObject);
            }
            currentSpawnGameObject.transform.position =
                spawnPositions[shiftPosition];
            // 선택된 적 캐릭터를 초기화하여 작동시킨다.
            currentSpawnGameObject.tag = enemyData.tagName;
            Enemy currentEnemy = currentSpawnGameObject.GetComponent <Enemy>();
            currentEnemy.InitEnemy(enemyData.HP, enemyData.AD, enemyData.MS);
            shiftPosition++;

            if (enemyData.tagName == "boss")
            {
                // TODO: 적 보스 캐릭터가 등장했다는 표시를 띄운다.
            }
            shiftPosition++;
        }
    }
Ejemplo n.º 10
0
    void WaveComplete()
    {
        waveInProgress = false;

        if (waveCounter < Waves.Length)
        {
            currentWave        = Waves[waveCounter];
            inBreakBetweenWave = true;
            breakTimeCounter   = breakTimeLength;
        }
        else
        {
            CompletedAllWaves();
        }
    }
Ejemplo n.º 11
0
    public void SetEnemyTypeData(int enemyType, float weight)
    {
        EnemyWaveData enemyData = enemyTypesData.Where(e => e.typeOfEnemy == (EnemyType)enemyType).FirstOrDefault();

        if (enemyData != null)
        {
            enemyData.weight = weight * 100f;
            if (weight > 0)
            {
                enemyData.enabled = true;
            }
            else
            {
                enemyData.enabled = false;
            }
        }
    }
 public void SpawnEnemyWave(EnemyWaveData wave)
 {
     StartCoroutine(SpawnEnemyWaveCoroutine(wave));
 }
Ejemplo n.º 13
0
    void SpawnEnemy(EnemyWaveData enemyData)
    {
        int positionPointer = 1;
        int shiftPosition   = 0;

        // 생성할 위치 값으로 생성할 유닛 수 판단.
        enemyData.amount = positionToAmount[enemyData.spawnPosition];
        //웨이브 표시.
        waveLb.text = enemyData.waveNo.ToString();

        // 생성해야하는 숫자만큼 loop
        for (int i = 0; i < enemyData.amount; i++)
        {
            // 생성할 위치 선택.
            while ((positionPointer & enemyData.spawnPosition) < 1)
            {
                shiftPosition++;
                positionPointer = 1 << shiftPosition;
            }
            // 오브젝트 풀에 사용가능한 게임 오브젝트가 있는지 점검.
            GameObject currentSpawnGameObject;
            if (!gameObjectPools [enemyData.type]
                .NextGameObject(out currentSpawnGameObject))
            {
                // 사용가능한 게임 오브젝트가 없다면 생성하여 추가한다.
                currentSpawnGameObject =
                    Instantiate(
                        gameObjectPools [enemyData.type].spawnObj,
                        gameObjectPoolPosition.transform.position,
                        Quaternion.identity) as GameObject;

                currentSpawnGameObject.transform.parent = gameObjectPoolPosition;
                currentSpawnGameObject.name             =
                    enemyData.type + gameObjectPools [enemyData.type].lastIndex;
                gameObjectPools [enemyData.type].AddGameObject(currentSpawnGameObject);
            }
            currentSpawnGameObject.transform.position =
                spawnPositions [shiftPosition];

            //선택된 적 캐릭터를 초기화하여 작동시킨다.
            currentSpawnGameObject.tag = enemyData.tagName;
            Enemy currentEnemy = currentSpawnGameObject.GetComponent <Enemy>();
            currentEnemy.InitEnemy(enemyData.HP, enemyData.AD, enemyData.MS);
            shiftPosition++;

            // 게임 오브젝트 풀에서 사용가능한 적 체력 표시 인터페이스가 있는지 체크.
            GameObject currentEnemyHPBar;
            if (!gameObjectPools [enemyHPBar.name]
                .NextGameObject(out currentEnemyHPBar))
            {
                // 사용가능한 게임 오브젝트가 없다면 생성하여 추가한다.
                currentEnemyHPBar =
                    Instantiate(
                        enemyHPBar,
                        gameObjectPoolPosition.transform.position,
                        Quaternion.identity) as GameObject;

                currentEnemyHPBar.transform.parent     = enemyHPBarRoot;
                currentEnemyHPBar.transform.localScale = Vector3.one;
                currentEnemyHPBar.name =
                    enemyHPBar.name + gameObjectPools [enemyHPBar.name].lastIndex;
                gameObjectPools [enemyHPBar.name].AddGameObject(currentEnemyHPBar);
            }
            // 적 체력 표시 인터페이스 할당.
            UISlider tempEnemyHPBarSlider =
                currentEnemyHPBar.GetComponent <UISlider>();
            currentEnemy.InitHPBar(
                tempEnemyHPBarSlider,
                enemyHPBarPanel,
                enemyHPBarCam);

            if (enemyData.tagName == "boss")
            {
                // 적 보스 캐릭터가 등장했다는 표시를 띄운다.
                bossEffectObj.gameObject.SetActive(true);
                bossEffectObj.resetOnPlay = true;
                bossEffectObj.Play(true);
            }
        }
    }
Ejemplo n.º 14
0
 public void SetEnemyWaveData(EnemyWaveData enemyWaveData)
 {
     this.enemyWaveData = enemyWaveData;
 }
Ejemplo n.º 15
0
    void SpawnEnemy(EnemyWaveData enemyData)
    {
        int positionPointer = 1;
        int shiftPosition = 0;
        // 생성할 위치 값으로 생성할 유닛 수 판단.
        enemyData.amount = positionToAmount[enemyData.spawnPosition];
        //웨이브 표시.
        waveLb.text = enemyData.waveNo.ToString();

        // 생성해야하는 숫자만큼 loop
        for (int i=0; i< enemyData.amount; i++)
        {
            // 생성할 위치 선택.
            while ((positionPointer & enemyData.spawnPosition) < 1)
            {
                shiftPosition++;
                positionPointer = 1 << shiftPosition;
            }
            // 오브젝트 풀에 사용가능한 게임 오브젝트가 있는지 점검.
            GameObject currentSpawnGameObject;
            if (!gameObjectPools [enemyData.type]
               .NextGameObject(out currentSpawnGameObject))
            {
                // 사용가능한 게임 오브젝트가 없다면 생성하여 추가한다.
                currentSpawnGameObject =
                    Instantiate(
                        gameObjectPools [enemyData.type].spawnObj,
                        gameObjectPoolPosition.transform.position,
                        Quaternion.identity) as GameObject;

                currentSpawnGameObject.transform.parent = gameObjectPoolPosition;
                currentSpawnGameObject.name =
                    enemyData.type + gameObjectPools [enemyData.type].lastIndex;
                gameObjectPools [enemyData.type].AddGameObject(currentSpawnGameObject);
            }
            currentSpawnGameObject.transform.position =
                spawnPositions [shiftPosition];

            //선택된 적 캐릭터를 초기화하여 작동시킨다.
            currentSpawnGameObject.tag = enemyData.tagName;
            Enemy currentEnemy = currentSpawnGameObject.GetComponent<Enemy>();
            currentEnemy.InitEnemy(enemyData.HP, enemyData.AD, enemyData.MS);
            shiftPosition++;

            // 게임 오브젝트 풀에서 사용가능한 적 체력 표시 인터페이스가 있는지 체크.
            GameObject currentEnemyHPBar;
            if (!gameObjectPools [enemyHPBar.name]
               .NextGameObject(out currentEnemyHPBar))
            {
                // 사용가능한 게임 오브젝트가 없다면 생성하여 추가한다.
                currentEnemyHPBar =
                    Instantiate(
                        enemyHPBar,
                        gameObjectPoolPosition.transform.position,
                        Quaternion.identity) as GameObject;

                currentEnemyHPBar.transform.parent = enemyHPBarRoot;
                currentEnemyHPBar.transform.localScale = Vector3.one;
                currentEnemyHPBar.name =
                    enemyHPBar.name + gameObjectPools [enemyHPBar.name].lastIndex;
                gameObjectPools [enemyHPBar.name].AddGameObject(currentEnemyHPBar);
            }
            // 적 체력 표시 인터페이스 할당.
            UISlider tempEnemyHPBarSlider =
                currentEnemyHPBar.GetComponent<UISlider>();
            currentEnemy.InitHPBar(
                tempEnemyHPBarSlider,
                enemyHPBarPanel,
                enemyHPBarCam);

            if (enemyData.tagName == "boss")
            {
                // 적 보스 캐릭터가 등장했다는 표시를 띄운다.
                bossEffectObj.gameObject.SetActive(true);
                bossEffectObj.resetOnPlay = true;
                bossEffectObj.Play(true);
            }
        }
    }
Ejemplo n.º 16
0
 public void Step(ref EnemyWaveData token, int condition)
 {
     _guiEntityView.enemyCountComponent.enemyCount += token.numberOfEnemiesToSpawn;
 }