Playing Music and Changing Scenes

[honorthrawn]

Hi! I am working on writing a game in Korge that uses the multiple scene feature. I have figured out I can select a random song and play it via code like this:
ps.tunes.add(resourcesVfs["music/Badlands.mp3"].readMusic())
ps.tunes.add(resourcesVfs["music/Cassette.mp3"].readMusic())
ps.tunes.add(resourcesVfs["music/Powerful.mp3"].readMusic())
ps.tunes.add(resourcesVfs["music/Soprano.mp3"].readMusic())
ps.tunes.shuffle()
ps.currentTune = ps.tunes[0].play()
ps is one of my objects -- stands for PlayerState. Just cramming it there for the time being. The problem is: the music starts just fine but as soon as I click a button that causes the scene to switch, the music stops. Ideally, I'd like to be able to start a song, play it until the end (even if scene changed) and then switch to a new song. Any ideas?

[soywiz]

Try this:

import korlibs.audio.sound.*
import korlibs.audio.sound.fade.*
import korlibs.datastructure.*
import korlibs.time.*
import korlibs.korge.*
import korlibs.korge.scene.*
import korlibs.korge.tween.*
import korlibs.korge.view.*
import korlibs.image.color.*
import korlibs.image.format.*
import korlibs.io.file.std.*
import korlibs.korge.input.*
import korlibs.korge.ui.*
import korlibs.math.geom.*
import korlibs.math.interpolation.*

suspend fun main() = Korge(windowSize = Size(512, 512), backgroundColor = Colors["#2b2b2b"]) {
    val sceneContainer = sceneContainer()

    sceneContainer.changeTo({ MyScene() })
}

class MyScene : Scene() {
    override suspend fun SContainer.sceneMain() {
        val minDegrees = (-16).degrees
        val maxDegrees = (+16).degrees

        val image = image(resourcesVfs["korge.png"].readBitmap()) {
            rotation = maxDegrees
            anchor(.5, .5)
            scale(0.8)
            position(256, 256)
        }

        run {

            val sound1 = AudioTone.generate(1.seconds, 5_000.0).toSound()

            uiVerticalStack {
                uiButton("play") {
                    onClick {
                        musicChannel.play(sound1, PlaybackParameters(infinitePlaybackTimes))
                    }
                }
                uiButton("fadeIn") {
                    onClick {
                        musicChannel.fadeIn()
                    }
                }
                uiButton("fadeOut") {
                    onClick {
                        musicChannel.fadeOut()
                    }
                }
                uiButton("stop") {
                    onClick {
                        musicChannel.stop()
                    }
                }
            }
        }

        while (true) {
            image.tween(image::rotation[minDegrees], time = 1.seconds, easing = Easing.EASE_IN_OUT)
            image.tween(image::rotation[maxDegrees], time = 1.seconds, easing = Easing.EASE_IN_OUT)
        }
    }
}

val Scene.musicChannel: AudioChannel by extraPropertyThis { AudioChannel("music", this) }
val Scene.voiceChannel: AudioChannel by extraPropertyThis { AudioChannel("voice", this) }
val Scene.effectsChannel1: AudioChannel by extraPropertyThis { AudioChannel("effects1", this, isLocal = true) }
val Scene.effectsChannel2: AudioChannel by extraPropertyThis { AudioChannel("effects2", this, isLocal = true) }

class AudioChannel(val name: String, val scene: Scene, val isLocal: Boolean = false) {
    val views get() = scene.views
    private val channelName = "sound-channel-$name"
    private var channel: SoundChannel?
        set(value) {
            views.setExtra(channelName, value)
        }
        get() = views.getExtraTyped(channelName)

    fun play(sound: Sound, params: PlaybackParameters = PlaybackParameters.DEFAULT) {
        channel?.stop()
        channel = sound.play(if (isLocal) scene.coroutineContext else views.views.coroutineContext, params)
    }

    fun stop() {
        channel?.stop()
    }

    suspend fun fadeIn(time: TimeSpan = DEFAULT_FADE_TIME, easing: Easing = DEFAULT_FADE_EASING) {
        channel?.fadeIn(time, easing)
    }

    suspend fun fadeOut(time: TimeSpan = DEFAULT_FADE_TIME, easing: Easing = DEFAULT_FADE_EASING) {
        channel?.fadeOut(time, easing)
    }
}

This example should work with hotreloading + also preserve channels between scenes since it is using the coroutine context from the views. We can validate this in a kproject, and maybe eventually move it to the code. Feel free to check it and please, let us know if it works as expected for you.

[honorthrawn]

Thank you for looking into it - I worked on it some more as well. I don't think the example is quite what I want but it did give me a new direction to go in. Here's what I have right now in case that helps others:
import com.soywiz.klock.*
import com.soywiz.korau.sound.*
import com.soywiz.korge.scene.*
import com.soywiz.korio.file.std.*

class MusicPlayer {
private var tunes = mutableListOf()
private var currentTune: SoundChannel? = null
private var currentTime: Double = 0.0
private var totalTime: Double = 0.0
private var currentSong = 0
private var loadedMusic = false
private var currentScene: Scene? = null

private suspend fun loadMusic() {
    println("Loading music")
    tunes.add(resourcesVfs["music/Badlands.mp3"].readMusic())
    tunes.add(resourcesVfs["music/Cassette.mp3"].readMusic())
    tunes.add(resourcesVfs["music/Powerful.mp3"].readMusic())
    tunes.add(resourcesVfs["music/Soprano.mp3"].readMusic())
    tunes.shuffle()
}

suspend fun playBackground(scene: Scene) {
    currentScene = scene
    println("Playing background music")
    if(!loadedMusic) {
        loadMusic()
        loadedMusic = true
    }
    if(currentTune == null) {
        playCurrentSong()
    }
}

private fun chooseNextSong() {
    if(currentTime < totalTime ) {
        println("song canceled, will resume")
    } else {
        println("Choosing next song")
        currentSong++
        currentTime = 0.0
        if (currentSong >= tunes.count()) {
            currentSong = 0
        }
        println("next song chosen")
    }
    if(currentTune != null && !currentTune!!.playing ) {
        playCurrentSong()
    }
}

private fun playCurrentSong() {
    println("Playing current song ${currentSong} @ ${currentTime}")
    val pb = PlaybackParameters(times = PlaybackTimes(1),
        startTime = TimeSpan(currentTime),
        onFinish = {
            println("on finish")
            chooseNextSong()
        },
        onCancel = {
            println("on Cancel")
            currentTime = currentTune?.current?.milliseconds ?: 0.00
            totalTime = currentTune?.total?.milliseconds ?: 0.00
            println("currentTime: ${currentTime} totalTime: ${totalTime}")
            chooseNextSong()
        } )
   // currentTune = tunes[currentSong].play(pb)
    currentTune = tunes[currentSong].play(currentScene!!.coroutineContext, pb )
}

}

[soywiz]

So what I provided was a mechanism to playback sounds and musics that persisted between scene changes.
There is another method, that might work better for you, that is to have a scene and a sceneContainer that never changes that handles music.
Then you can communicate with that scene somehow.

For example:

fun main() = korge {
  injector.mapInstance(MusicCommuncation())
  sceneContainer().changeTo { MusicScene(get()) }
  sceneContainer().changeTo { Ingame1Scene(get()) }
}

class MusicCommuncation {
  val musicChangeRequest = Signal<String>()
  val musicStopRequest = Signal<Unit>()
}

class MusicScene(val musicCommuncation: MusicCommuncation) : Scene() {
    override suspend fun SContainer.sceneMain() {
       // Do your music playback
      musicCommuncation.musicChangeRequest { }
      musicCommuncation.musicStopRequest{ }
    }
}
class Ingame1Scene(val musicCommuncation: MusicCommuncation) : Scene() {
    override suspend fun SContainer.sceneMain() {
    }
}
class Ingame2Scene(val musicCommuncation: MusicCommuncation) : Scene() {
    override suspend fun SContainer.sceneMain() {
         musicCommuncation.musicChangeRequest("something")
    }
}

[honorthrawn]

Thank you that is great. I didn't know you could have more than one active scene at a time. I managed to get it working with that approach and I think it fits in better with my understanding and the design of what I have so far.

[soywiz]

Glad to hear that. In addition to multiple scenes in a single level, you can also have scenes inside scenes like subscenes. So you could also have a game wrapper scene handling the music and other things, and then you can have for example a game scene that includes a ui overlay scene (handling for example scores) and an ingame scene that separates responsibilities.