Пример #1
0
    void Update()
    {
        if (saveWhenSPressed && trackPath != "" && Input.GetKeyDown(KeyCode.S))
        {
            GameTrackReader.SerializeAndSave(track, trackPath);
        }

        if (nextBeat < 0)
        {
            return;
        }

        double beatTime = BeatController.BeatTime;

        if (beatTime >= nextBeat)
        {
            if (!track.beatEvents[currentChunkIndex].silence)
            {
                for (int i = 0; i < beatEvent.Length; ++i)
                {
                    beatEvent[i].Beat(track.beatEvents[currentChunkIndex].noteDuration);
                }
            }

            if (logBeat)
            {
                Debug.Log("Doing beat stuff on " + nextBeat + " " + track.beatEvents[currentChunkIndex].chunkType);
            }

            bool looping = false;
            if (track.beatEvents[currentChunkIndex].chunkType == ChunkType.Loop)
            {
                double loopBeat = nextBeat + track.beatEvents[currentChunkIndex].loopDuration;
                if (lastEvent || loopBeat < chunkBeat)
                {
                    nextBeat = loopBeat;
                    looping  = true;
                }
            }

            if (!looping)
            {
                currentChunkIndex = nextChunkIndex;
                nextBeat          = chunkBeat;

                ++nextChunkIndex;

                if (nextChunkIndex < track.beatEvents.Length)
                {
                    chunkBeat = track.beatEvents[nextChunkIndex].beat + track.beatEvents[nextChunkIndex].numPos / track.beatEvents[nextChunkIndex].denomPos;
                }
                else
                {
                    lastEvent = true;
                    chunkBeat = -1;
                }
            }
        }
    }
Пример #2
0
    void Update()
    {
        if (saveWhenSPressed && trackPath != "" && Input.GetKeyDown(KeyCode.S))
        {
            GameTrackReader.NewSerializeAndSave(track, trackPath);
        }

        if (nextBeat < 0)
        {
            return;
        }

        double beatTime = BeatController.BeatTime;

        if (beatTime >= nextBeat)
        {
            if (!currentPattern[noteIndex].silence)
            {
                for (int i = 0; i < beatEvent.Length; ++i)
                {
                    beatEvent[i].Beat(currentPattern[noteIndex].noteDuration);
                }
            }


            if (logBeat)
            {
                Debug.Log("Doing beat stuff on " + nextBeat + " " + track.chunks[currentChunkIndex].chunkType);
            }

            nextBeat += currentPattern[noteIndex].noteDuration;
            ++noteIndex;

            bool changePattern = chunkBeat >= 0 && nextBeat >= chunkBeat;

            if (track.chunks[currentChunkIndex].chunkType == ChunkType.Loop)
            {
                noteIndex = noteIndex % currentPattern.Length;
            }
            else
            {
                changePattern |= noteIndex >= currentPattern.Length;
            }

            if (changePattern)
            {
                ChangePattern();
            }
        }
    }
Пример #3
0
    void Start()
    {
        if (trackPath != "")
        {
            GameTrackReader.LoadTrackFromPath(trackPath, ref track);
        }

        nextBeat = track.beatEvents[currentChunkIndex].beat + track.beatEvents[currentChunkIndex].numPos / track.beatEvents[currentChunkIndex].denomPos;
        ++nextChunkIndex;
        if (nextChunkIndex < track.beatEvents.Length)
        {
            chunkBeat = track.beatEvents[nextChunkIndex].beat + track.beatEvents[nextChunkIndex].numPos / track.beatEvents[nextChunkIndex].denomPos;
        }
        else
        {
            lastEvent = true;
        }
    }
Пример #4
0
    void Start()
    {
        if (trackPath != "")
        {
            GameTrackReader.NewLoadTrackFromPath(trackPath, ref track);
        }

        currentChunkIndex = 0;
        nextChunkIndex    = 1;
        currentPattern    = track.patterns[track.chunks[currentChunkIndex].pIndex].notes;
        noteIndex         = 0;

        nextBeat = track.chunks[currentChunkIndex].beat + track.chunks[currentChunkIndex].numPos / track.chunks[currentChunkIndex].denomPos;
        if (nextChunkIndex < track.chunks.Length)
        {
            chunkBeat = track.chunks[nextChunkIndex].beat + track.chunks[nextChunkIndex].numPos / track.chunks[nextChunkIndex].denomPos;
        }
        else
        {
            lastEvent = true;
        }
    }