How to create a Unity Rhythm Game Part 2: Generating the Steps

RSS
Follow by Email
Facebook0
Google+0
http://blog.phantombadger.com/2016/05/26/how-to-create-a-unity-rhythm-game-part-2-generating-the-steps/

Part 1

In the last article we went over how to create a parser to dynamically convert a valid .sm file (with the exception of some edge cases, such as the song having multiple bpms). So we now have a fully populated data structure that looks something like this:

SM Data Structure Example

If that didn’t make much sense, then don’t worry too much about it! The previous article goes over the structure in a little more detail. Now let’s tackle actually using this data. The plan is to dynamically spawn the arrows at the correct time so that when they fall down the screen (at a speed determined by the user’s difficulty) they hit the detection zone in sync with the song.

This may sound like a difficult task, but we can break it down rather easily with a simple physics equation;

Speed = Distance / Time

We want to find the time in the song that we should spawn the arrow, we are given the speed through the difficulty the user has selected (The arrows/steps will move faster at a higher speed) and we pick a location off-screen as our fixed ‘spawn distance.’ So with this information in mind we can re-arrange the equation to

Time = Distance / Speed

 Now remember this equation because it becomes fundamental to the calculation later.

The first thing is to set up the actual spawning process. To do this we need to Initialize some of the variables we’ll need.

    public void InitSteps(Song_Parser.Metadata newSongData, 
                          Song_Parser.difficulties newDifficulty)
    {
        songData = newSongData;
        isInit = true;

        //We estimate how many seconds a single 'bar' will be in the song
        //Using the bpm provided in the song data
        barTime = (60.0f / songData.bpm) * 4.0f;
        
        difficulty = newDifficulty;
        distance = originalDistance;

        //We then use the provided difficulty to determine how fast the arrows 
        //will be going
        switch (difficulty)
        {
            case Song_Parser.difficulties.beginner:
                arrowSpeed = 0.007f;
                noteData = songData.beginner;
                break;
            case Song_Parser.difficulties.easy:
                arrowSpeed = 0.009f;
                noteData = songData.easy;
                break;
            case Song_Parser.difficulties.medium:
                arrowSpeed = 0.011f;
                noteData = songData.medium;
                break;
            case Song_Parser.difficulties.hard:
                arrowSpeed = 0.013f;
                noteData = songData.hard;
                break;
            case Song_Parser.difficulties.challenge:
                arrowSpeed = 0.016f;
                noteData = songData.challenge;
                break;
            default:
                goto case Song_Parser.difficulties.easy;
        }

        //This variable is needed when we look at changing the speed of the song
        //with the variable BPM mechanic
        originalArrowSpeed = arrowSpeed;
    }

 A lot of whats being done here seems fairly straight forward, we are initializing the variables we need and setting the speed of the arrows to match the chosen difficulty, with the exception of one line.

barTime = (60.0f / songData.bpm) * 4.0f;

 This line may seem a little weird, but what we’re doing is estimating how much time a bar will take in seconds given the song’s bpm. Bpm is recorded as ‘beats per minute’ meaning that if we had 120 bpm then we could represent that as

120 Beats = 60 seconds

So lets take that logic and make it a little more generic

BPM = 60 Seconds

From this we can calculate the time taken for a single ‘beat’ by dividing the BPM by 60

Time for a single note = BPM / 60

And we know that in most cases, a bar will be 4 notes, now this can differ, but in these cases the notes are often closer together, meaning that the total time taken for the bar would be the same, despite the additional notes in it. If a bar is 4 notes we can modify the above equation to

Time for a Bar = 4 * Time for a single note

Time for a Bar = 4 * (BPM / 60)

In case it wasn’t obvious yet, there’s gunna be a bit of Math involved when calculating these values, I’ll go through it the best I can when it crops up however.

So now that initialization is done, let’s look at the meat of the generation process.

    // Update is called once per frame
    void Update () 
    {
        //If we're done initializing the rest of the world
        //And we havent gone through all the bars of the song yet
        if (isInit && barCount < noteData.bars.Count) 
        { 
            //We calculate the time offset using the s=d/t equation (t=d/s) 
            distance = originalDistance; 
            float timeOffset = distance / arrowSpeed;

            //Get the current time through the song 
            songTimer = heartAudio.time; 

            //If the current song time - the time Offset is greater than 
            //the time taken for all executed bars so far 
            //then it's time for us to spawn the next bar's notes 
            if (songTimer - timeOffset >= (barExecutedTime - barTime))
            {
                StartCoroutine(PlaceBar(noteData.bars[barCount++]));

                barExecutedTime += barTime;
            }
        }
    }

The above code is called through our update method, which is a function called once per frame by the Unity engine, we need to keep this in mind as it can affect how we structure our game logic.

We first check whether the game is still initializing or not, if it isn’t we check how many bars of notes we have ‘spawned’ so far, as long as it isn’t the end of the song, we go into the main body of the method.

We then calculate the intended time offset to spawn the arrows using the current arrow’s speed and the intended spawn distance, using the equation we showed before; t=d/s.

The last piece of information we need to keep track of is the current time progress of the song (ie, how far through the song we are in seconds). Which we get through the heartAudio variable, which contains the Unity AudioSource object we’re playing music from.

Now that we have all the info we need, we can decide whether to spawn the next bar of notes on this frame or not. In order to do that we check whether the current time of the song, minus the offset required to spawn the arrows on-time is larger than the time taken to go through all the executed bars so far, minus one ‘bar time.’ The logic behind this is a little funny, and it took some trial and error to get it working, so don’t be disheartened if it doesn’t make a lot of sense to you.

If this is true; we call a Unity-specific function called ‘StartCoroutine.’ StartCoroutine runs the function passed into it in a separate thread, allowing it to run parallel to the rest of the game. If we didnt have this then we’d need to wait until all the arrows were spawned before the update loop progressed, in some games this isn’t an issue, but in a rhythm game where timing is key and there’s constant attention by the user we want anything lengthy to be run parallel during the main game loop.

We pass in a function called PlaceBars and the value of barCount before incrementing it (adding 1 to it’s value), barCount allows us to know which bar in our data structure we need to place.

    IEnumerator PlaceBar(List<Song_Parser.Notes> bar)
    {
        for (int i = 0; i &lt; bar.Count; i++)
        {
            if (bar[i].left)
            {
                GameObject obj = (GameObject)Instantiate(leftArrow, new Vector3(leftArrowBack.transform.position.x, leftArrowBack.transform.position.y + distance, leftArrowBack.transform.position.z - 0.3f), Quaternion.identity);
                obj.GetComponent<Arrow_Movement>().arrowBack = leftArrowBack;
            }
            if (bar[i].down)
            {
                GameObject obj = (GameObject)Instantiate(downArrow, new Vector3(downArrowBack.transform.position.x, downArrowBack.transform.position.y + distance, downArrowBack.transform.position.z - 0.3f), Quaternion.identity);
                obj.GetComponent<Arrow_Movement>().arrowBack = downArrowBack;
            }
            if (bar[i].up)
            {
                GameObject obj = (GameObject)Instantiate(upArrow, new Vector3(upArrowBack.transform.position.x, upArrowBack.transform.position.y + distance, upArrowBack.transform.position.z - 0.3f), Quaternion.identity);
                obj.GetComponent<Arrow_Movement>().arrowBack = upArrowBack;
            }
            if (bar[i].right)
            {
                GameObject obj = (GameObject)Instantiate(rightArrow, new Vector3(rightArrowBack.transform.position.x, rightArrowBack.transform.position.y + distance, rightArrowBack.transform.position.z - 0.3f), Quaternion.identity);
                obj.GetComponent<Arrow_Movement>().arrowBack = rightArrowBack;
            }
            yield return new WaitForSeconds((barTime / bar.Count) - Time.deltaTime);
        }
    }

This PlaceBar method is called on a new thread, because we called this method through a Coroutine, it has to have an ‘IEnumerator’ return type. Because of this we can use Unity’s WaitForSeconds class to delay the thread for a certain period of time.

This method goes through all of the notes in that bar, and depending on which ‘step arrows’ are meant to be spawned, it creates an instance of that game object and initializes some stuff in their scripts.

Once spawning the correct note, the method and thread waits for some time with the line:

yield return new WaitForSeconds((barTime / bar.Count) - Time.deltaTime);

In a usual method, a return would end that method’s execution and return a value to whatever called it. With a method that returns IEnumerator however, we can use a ‘yield return’ to return multiple things. What yield return actually does is it returns a value, and then continues the execution of the method until it’s executed all the code in it and executes normally.

In this instance, we exploit this by returning a reference to the previously mentioned WaitForSeconds class. We get the method to wait for however long it takes to reach the time where the next note should appear. Otherwise, all the notes in the bar will be spawned at once, instead of separately when they should.

We use ‘barTime’ which contains the time taken for a single bar from our initial estimate, divide it by the number of notes in this bar (bar.Count) in order to find the time taken for each note in this bar. Finally, we subtract the current deltaTime. Delta Time is the difference in time between this frame and the last, putting this in prevents any delays caused by the instantiation process to prevent notes being spawned on time.

With the steps generated, we add to the total barExecutedTime seen previously, and get ready to spawn the next bar!

In you were after a starting point on making a Rhythm game then this will probably be enough for you, the next part of this writeup will be a quick one discussing how I allowed the user to generate a new BPM for a song by hitting the space bar to the rhythm wanted.

5 thoughts on “How to create a Unity Rhythm Game Part 2: Generating the Steps

  1. Leon says:

    Cool stuff!
    I’m working on a rhythm game and this is really useful.
    I am trying to make a tool that allows the game designers to manually design the step sheet. How would one go about creating the step sheets based on a music file?

    • PhantomBadger says:

      Thank you! I’m glad this article could be of use!

      Hmm, I’m not sure, I would look into a form of playing the music, and in real-time perhaps pressing arrow keys on the keyboard to write a step at a specific time slot, using a similar bar/time system as described in that article, but in reverse, if that makes sense?

      So you could play the required song, and every tick its playing keep track of what bar you are on in the song, continually writing to a structure (Like the list of notes I’ve used) and even potentially which note in that bar you’re on, though that could get iffy with anything that isn’t 4. Then when receiving user input you just write that step into the current bar the song is at. There’d be a lot more tweaking and consideration required but that would be my initial starting point!

Leave a Reply

Your email address will not be published. Required fields are marked *