5

Description

"# Introduction Stuff\r\n\r\nHello! I'm wobbachu, and I am going to be showing you how to do cool interactive music stuff. Stuff like the different area variations in Banjo Kazooie, and those fast-paced amen break audio tracks in Ultrakill!\r\n\r\nRecently, Godot added some new features in 4.3 to make these sort of effects more feasible than ever! So let's get started, shall we? In this part of a micro-series about adaptive music in Godot, I am going to be covering how to take advantage of AudioStreamSynchronized!\r\nDoing these tutorials take a lot of time, and it takes a lot of space to read all of my reading style, so I made the split for reading convenience! Whenever any parts come out in the future, I'll be sure to edit this document to add those future parts for further reading convenience! \r\n\r\nReminder that this tutorial is made in Godot 4.3. This is not compatible with older versions. With newer versions, however, I'll add some addendums here whenever anything changes.\r\n\r\n# Step 1: Setting Up the Stage\r\n\r\nOkay. This stuff is kinda cool.\r\nBut first, let's set up the basics to play around in.\r\n\r\nI have set up a small playground of sorts to test this out on. This is a Node2D area that has a Camera2D, a CharacterBody2D with the default script in it, a StaticBody2D that acts as the platform for our character to be moved in, and two StaticBody2Ds that have the collision of a world border.\r\n\r\nFeel free to set this up yourself! But if you need resources...\r\nCheck out the Github repository URL and open it in Godot. You can use it to follow along! But generally, any set-up that has a moveable CharacterBody2D should do.\r\n\r\n# Step 2: Adding in the \ud83c\udfb6 Music \ud83c\udfb6\r\n\r\nAdd in an AudioStreamPlayer!\r\n\r\nYou can name them anything you want. But I'll call em... Josh!\r\n\r\nNext, with AudioStreamPlayer selected, go into the inspector and... instead of dragging in an audio file immediately, click on the dropdown and select \"New AudioStreamSynchronized\"\r\n\r\n\r\nYou should see something like this:\r\n\r\nFrom there, for this example, I am going to click the \"Add Stream\" button twice! This will give us two streams to work with (which is perfectly fine for this example, and what you learn here can be applied to more than 2 :3).\r\nResult:\r\n\r\n\r\nAnd from here, I am going to add in two of my rushed tracks I made specifically for this tutorial (plz don't bully me .w.). It is recommended that the two tracks you use here have the same length, to prevent desyncing (unless if that's what you want, of course)\r\nResult:\r\n\r\n\r\nSet the AudioStreamPlayer to Autoplay (for ease of testing right now) aaaaaand\r\n\r\nExcellent! Now we have two tracks that you can play simultaneously!... Now what?\r\nWell...\r\n\r\n# Step 3: Manipulating Track Volume\r\n\r\nYou see these thingys below the stream parameter for the streams?\r\n\r\n\r\nWe're gonna be using code to manipulate these to \"turn on\" and \"off\" the tracks on command!\r\nFor the ease of use and programming, I'll move the AudioStreamPlayer to be the child of the CharacterBody2D.\r\n\r\n\r\nFirst, we're gonna be adding some initialization variables above the functions.\r\n```\r\n@onready var adaptive_stuffs: AudioStreamPlayer = $Josh #replace \"$Josh\" with wherever the AudioStreamPlayer is.\r\n#alternatively, you can do @export (@export var adaptive_stuffs: AudioStreamPlayer) to select wherever the AudioStreamPlayer is.\r\nvar moosic: AudioStreamSynchronized\r\nvar drum_vol: float = -13.17\r\n```\r\n\r\nthe `moosic` variable is stream we're gonna using to manipulate the stream variables. The `adaptive_stuffs` variable is the object where we're gonna be accessing the audio stream (`moosic`) from.\r\n`moosic` contains the array of streams. A stream... with streams inside of it.\r\n\r\nNext, we're gonna go into `func _ready() -> void:` to set up the magic we are about to do.\r\n\r\n```\r\nif adaptive_stuffs.stream is AudioStreamSynchronized:\r\n\tmoosic = adaptive_stuffs.stream as AudioStreamSynchronized\r\n\tprint_debug(\"Dis oki\")\r\nelse:\r\n\tprint_debug(\"Dis not oki\")\r\n```\r\n\r\nThis, first, sets up a fail-safe system. It checks if the stream that the `AudioStreamPlayer` has is an `AudioStreamSynchronized`. If not, it throws \"Dis not oki\" into the output. If it IS an `AudioStreamSynchronized`, then it proceeds!\r\nSecondly, if the stream is an `AudioStreamSynchronized`, it assigns our stream variable (`moosic`) to that stream as the class of an `AudioStreamSynchronized`.\r\n\r\nAnd now...\r\n\r\n# Step 4: Time for the magic \u2728\r\n\r\nWe can now use the function `set_sync_stream_volume()`!\r\nUnfortunately, it does not show up in Godot's autofill system due to technical reasons. So you'll just need to type in the function exactly.\r\n`moosic.set_sync_stream_volume()` tells the `AudioStreamSynchronized` resource (`moosic`) which index of array of streams to modify (As in, which stream we want to modify. Also, the first parameter) and what value to modify the that steam's volume to (the second parameter)\r\nSo, to initialize the volume of our drum track, we'll add in this after our `moosic` assignment.\r\n\r\n```\r\nif adaptive_stuffs.stream is AudioStreamSynchronized:\r\n\tmoosic = adaptive_stuffs.stream as AudioStreamSynchronized\r\n\tprint_debug(\"Dis oki\")\r\n\tmoosic.set_sync_stream_volume(1, -13.17)\r\nelse:\r\n\tprint_debug(\"Dis not oki\")\r\n```\r\n\r\n-13.17 decibels should be enough to silence the drum track to our moral ears.\r\nThis line should guarantee that we'll get the drumtrack won't be audible when we start the game.\r\nAlso important to note is that arrays are 0-indexed. So the drumtrack is the second item in the array, but accessed as \"1\". The first item is then accessed as \"0\".\r\n\r\n**Now we have opened the floodgates to do all kinds of cool stuff**\r\nBut for a quick example though, I'll use our new-found powers to make the drum-tracks only be audible when we move!\r\n\r\nIn the `func _physics_process(delta: float) -> void:` function (assuming you are using the default CharacterBody2D script):\r\n```\r\nvar direction := Input.get_axis(\"ui_left\", \"ui_right\")\r\nif direction:\r\n\tvelocity.x = direction * SPEED\r\n\tmoosic.set_sync_stream_volume(1, 0.0) # Added\r\nelse:\r\n\tvelocity.x = move_toward(velocity.x, 0, SPEED)\r\n\tmoosic.set_sync_stream_volume(1, -13.17) # Added\r\n```\r\n\r\nLet's test it out now!\r\nAaaaaanddddd...\r\n[video:tutorial 1](https:\/\/file.garden\/YmRvsICqGHPlp2ER\/TutorialDirectory\/Tutorial1.mp4)\r\n\r\nI mean, it's alriiiiiiight. But it can be improved. Notice how the music suddenly cuts when we aren't moving for even a smidge of a second? It's not a smooth cut at all! So let's interpolate it!\r\n\r\n# Step 5: Improving our Magic\r\n\r\nWe're gonna be using that drum volume variable that we set up earlier! Cool foreshadowing huh?\r\nWell first for good programming practice, let's set our initial volume of the track to the `drum_vol` variable!\r\n```\r\nvar drum_vol: float = -13.17\r\n\r\nfunc _ready() -> void:\r\n\tif adaptive_stuffs.stream is AudioStreamSynchronized:\r\n\t\tmoosic = adaptive_stuffs.stream as AudioStreamSynchronized\r\n\t\tprint_debug(\"Dis oki\")\r\n\t\tmoosic.set_sync_stream_volume(1, drum_vol) # changed\r\n\telse:\r\n\t\tprint_debug(\"Dis not oki\")\r\n```\r\n\r\nNow let's remove our function calls we used earlier. We're gonna be using a \u2728 *custom function* \u2728 to handle the volume (and reduce repetition, another good programming practice)\r\nLike so.\r\n```\r\nvar direction := Input.get_axis(\"ui_left\", \"ui_right\")\r\n\tif direction:\r\n\t\tvelocity.x = direction * SPEED\r\n\t\t# removed\r\n\telse:\r\n\t\tvelocity.x = move_toward(velocity.x, 0, SPEED)\r\n\t\t# removed\r\n```\r\n\r\nAnd now... for the new function! Ya can call it anything you want, but I'll call it `moveToVol`. I'll also add in two parameters: `streamIndex: int` (for choosing the index we wanna manipulate) and `speed: float` parameter for my method of \"interpolation\", but you are free to use any method you want, as long as it get it from the current volume to the new volume in a smooth manner.\r\n\r\n```\r\nfunc moveToVol(streamIndex: int, speed: float) -> void:\r\n\tpass # This is just here so it doesn't throw an error lol.\r\n```\r\nNow let's work on our logic!\r\n\r\n```\r\nfunc moveToVol(streamIndex: int, speed: float) -> void:\r\n\tdrum_vol += speed # added\r\n\tdrum_vol = clampf(drum_vol, -13.17, 0) # added\r\n\tmoosic.set_sync_stream_volume(streamIndex, drum_vol) # added\r\n```\r\nThis is what I ended up doing. The `drum_vol` gets increased by the `speed` variable, then `drum_vol` then gets clamped between the minimum volume and the max so we don't blow out our speakers (high decibel values are bad for your health). Here, I am doing this in-between -13.17. BUT, you can set the minimum and maximum anything you want! You could even set up two new parameters in the function (`minVol` and `maxVol`) to set up the minimum and the maximum per function call!\r\nAnd finally, the sync stream volume of the specified index in the stream array is set to the `drum_vol` variable we have calculated.\r\n\r\nLet's now call the function!\r\n```\r\nvar direction := Input.get_axis(\"ui_left\", \"ui_right\")\r\nif direction:\r\n\tvelocity.x = direction * SPEED\r\n\tchangeVol(1, 0.1) # added\r\nelse:\r\n\tvelocity.x = move_toward(velocity.x, 0, SPEED)\r\n\tchangeVol(1, -0.1) #added\r\n```\r\nFor this example, I am using the rather slow speed of 0.1 to demonstrate the smoothness of our new volume.\r\n\r\nNow let's test it!\r\n[video:tutorial 2](https:\/\/file.garden\/YmRvsICqGHPlp2ER\/TutorialDirectory\/Tutorial2.mp4)\r\nYay! It's smooth!\r\n\r\nOh, and as a safety precaution, let's add something that will let us know if we forgot to add an `AudioStreamSynchronized` to our music player! If we forgot to assign our stream as `AudioStreamSynchronized`, and we DIDN'T do this check, we'd throw an error because we'd be calling a function (set_sync_stream_volume) that doesn't exist to the other AudioStream classes.\r\n\r\n```\r\nif moosic:\r\n\tdrum_vol += speed\r\n\tdrum_vol = clampf(drum_vol, -13.17, 0)\r\n\tmoosic.set_sync_stream_volume(streamIndex, drum_vol)\r\nelse:\r\n\tprint_debug(\"The stream is not an AudioStreamSynchronized\")\r\n```\r\nThis checks if `moosic` has been assigned {because unassigned variables are \"falsy\" (return false when checked)}. If it's not assigned (because of the stream not being a `AudioStreamSynchronized` class) It will print a less annoying print_debug message into your output!\r\n\r\n\r\n# Conclusion\r\n\r\nCongratulations! Now you have learned how to utilize `AudioStreamSynchronized`! There are lots of applications you can use with this on its own!\r\n\r\nBut what if... you want to do something more?\r\n\r\nThat question is what we will answer in the next part, where I will go over `AudioStreamInteractive`!\r\nThanks for reading!\r\n\r\nFeel free to experiment and even improve on the concepts I introduced here. I'd love to see how your escapades in the comments! I love seeing how people apply concepts!\r\nFeel free to leave feedback and questions in the comments as well!"

Screenshots

Main code

extends CharacterBody2D

const SPEED = 300.0
const JUMP_VELOCITY = -400.0

@onready var adaptive_stuffs: AudioStreamPlayer = $Josh
var moosic: AudioStreamSynchronized
var drum_vol: float = -13.17

func _ready() -> void:
	if adaptive_stuffs.stream is AudioStreamSynchronized:
		moosic = adaptive_stuffs.stream as AudioStreamSynchronized
		print_debug("Dis oki")
		moosic.set_sync_stream_volume(1, -13.17)
	else:
		print_debug("Dis not oki")

func _physics_process(delta: float) -> void:
	# Add the gravity.
	if not is_on_floor():
		velocity += get_gravity() * delta

	# Handle jump.
	if Input.is_action_just_pressed("ui_accept") and is_on_floor():
		velocity.y = JUMP_VELOCITY

	# Get the input direction and handle the movement/deceleration.
	# As good practice, you should replace UI actions with custom gameplay actions.
	var direction := Input.get_axis("ui_left", "ui_right")
	if direction:
		velocity.x = direction * SPEED
		changeVol(1, 0.1)
	else:
		velocity.x = move_toward(velocity.x, 0, SPEED)
		changeVol(1, -0.1)

	move_and_slide()

func changeVol(streamIndex: int, speed: float) -> void:
	if moosic:
		drum_vol += speed
		drum_vol = clampf(drum_vol, -13.17, 0)
		moosic.set_sync_stream_volume(streamIndex, drum_vol)
	else:
		print_debug("The stream is not an AudioStreamSynchronized")

Comments