Ejemplo n.º 1
0
    // Spawn all the enemies in a given wave
    private void spawnWave(WaveTuple tuple)
    {
        // Adjust the camera size and scroll speed
        if (!freeplayMode)
        {
            Camera.main.GetComponent <CameraSmoothZoom> ().addToCameraSize(tuple.cameraSizeChange);
            ScrollManager.setScrollVelo(tuple.scrollDirection, tuple.scrollSpeed);
        }
        else
        {
            ScrollManager.setScrollVelo(direction.down, 5);
        }

        Wave w = tuple.wave;

        if (w == null)
        {
            return;
        }

        // Re-initialize the spawners array and then spawn the wave
        initSpawnersArray();
        List <TypeNumPair>[] waveSpawns =
        {
            w.TopSpawner,
            w.BotSpawner,
            w.LeftSpawner,
            w.RightSpawner,
            w.TopFarLeft,
            w.TopMidLeft,
            w.TopMidRight,
            w.TopFarRight
        };

        currently_spawning = true;
        StartCoroutine(spawnLoop(waveSpawns));
    }
Ejemplo n.º 2
0
    // Construct a new sequence out of the freeplay waves, based on the multiplier
    private Sequence newFreeplaySeq()
    {
        setFreeplayWaves();

        Sequence newSeq  = new Sequence();
        int      waveNum = baseFreeplayWaveNum + freeplayMult;

        for (int i = 0; i < waveNum; i++)
        {
            int       randIndex    = Random.Range(0, freeplayWaves.Length);
            int       randThresh   = Random.Range(1, 5) + freeplayMult;
            WaveTuple newWaveTuple = new WaveTuple(Trigger.RemainingEnemies, randThresh, freeplayWaves [randIndex]);
            newSeq.waveTuples.Add(newWaveTuple);

            for (int j = 1; j < freeplayMult; j++)
            {
                randIndex    = Random.Range(0, freeplayWaves.Length);
                newWaveTuple = new WaveTuple(Trigger.Time, 1, freeplayWaves [randIndex]);
                newSeq.waveTuples.Add(newWaveTuple);
            }
        }

        return(newSeq);
    }
Ejemplo n.º 3
0
    // Play a sequence of waves, pausing at each trigger condition
    IEnumerator playSequence()
    {
        Sequence sequence;

        if (!freeplayMode)
        {
            sequence = sequences [sequenceIndex];
        }
        else
        {
            sequence = freeplaySeq;
        }

        if (sequence == null)
        {
            yield break;
        }

        // Fixed delay before every sequence
        yield return(new WaitForSeconds(delayBeforeSeq));

        for (int x = 0; x < sequence.waveTuples.Count; x++)
        {
            WaveTuple tuple = sequence.waveTuples [x];

            // Wait until condition is met
            if (tuple.condition == Trigger.RemainingEnemies)
            {
                yield return(new WaitForEndOfFrame());

                yield return(new WaitUntil(() => GM.Instance.enemies.Count <= tuple.threshold && !currently_spawning));

                yield return(new WaitForSeconds(delayBetweenSeq));
            }
            else if (tuple.condition == Trigger.Time)
            {
                yield return(new WaitForSeconds(tuple.threshold));
            }
            spawnWave(tuple);
            yield return(new WaitForEndOfFrame());
        }

        //print("finish them");
        yield return(new WaitUntil(() => GM.Instance.enemies.Count <= 0 && !currently_spawning));

        yield return(new WaitForSeconds(delayAfterSeq));

        if (!freeplayMode)
        {
            sequenceIndex++;
        }
        else
        {
            freeplayCounter++;
            if (freeplayCounter % 3 == 0)
            {
                freeplayMult++;
            }
        }

        idle = true;
        GM.Instance.handleSequenceOver();
    }