more cleanup

Author: NikkyAI

src/desktopMain/kotlin/nestdrop/deck/Deck.kt

@@ -43,11 +43,9 @@ import tags.pickItemToGenerate
 import tags.presetTagsMapping
 import ui.screens.imgSpritesMap
 import ui.screens.presetsMap
-import utils.HistoryNotNull
 import utils.prettyPrint
 import utils.runningHistory
 import utils.runningHistoryNotNull
-import kotlin.math.roundToInt
 import kotlin.time.Duration.Companion.milliseconds
 import kotlin.time.Duration.Companion.seconds
 
@@ -183,23 +181,6 @@ class Deck(
             pulseWidth.startFlows()
             waveForm.startFlows()
             enabled.startFlows()
-
-//            Link.bpm
-//                .combine(bpmSyncMultiplier) { bpm, multiplier ->
-//                    val beatsPerSecond = bpm / 60.0f
-//                    beatsPerSecond / multiplier
-//                }
-//                .map {
-//                    (it * 100).roundToInt() / 100f
-//                }
-//                .combine(bpmSyncEnabled) { a, b -> a to b }
-//                .distinctUntilChanged()
-//                .onEach { (value, toggle) ->
-//                    if (toggle) {
-//                        effectSpeed.value = value
-//                    }
-//                }
-//                .launchIn(flowScope)
         }
     }
 
@@ -252,45 +233,10 @@ class Deck(
 
     @Immutable
     inner class PresetSwitching() {
-        val transitionTime =
-            MutableStateFlow(1f) // OscSynced.Value("/deck$N/transitionTime", 1.0f, target = Target.TouchOSC)
-        val triggerTime =
-            MutableStateFlow(0.75f) // OscSynced.Value("/deck$N/triggerTime", 0.75f, target = Target.TouchOSC)
-//        val hasSwitched = MutableStateFlow(false)
-        private val hasSwitchedNew = MutableStateFlow(false)
-        val hasSwitched = hasSwitchedNew.asStateFlow()
-
-        suspend fun beatFlow(
-            flow: Flow<HistoryNotNull<Double>>
-        ) = combine(
-            flow,
-            beatFrame,
-            triggerTime,
-            isEnabled,
-        ) { (currentBeat, lastBeat), beatFrame, triggerTime, isEnabled ->
-            val triggerAt = triggerTime * beatFrame
-//                logger.info { "currentBeat: $currentBeat" }
-//                logger.info { "triggerAt: $triggerAt" }
-//                logger.info { "lastBeat: $lastBeat" }
-            //TODO: reset hasSwitched after transition time has passed
-            if (isEnabled && !hasSwitchedNew.value) {
-                val shouldTrigger = (lastBeat < triggerAt && currentBeat >= triggerAt) || (lastBeat > beatFrame && currentBeat >= triggerAt)
-
-                if(shouldTrigger) {
-                    flowScope.launch {
-                        logger.info { "$deckName triggered at $currentBeat ($triggerAt)" }
-                    }
-                    hasSwitchedNew.value = true
-                    flowScope.launch {
-                        val transitionTime = ndTime.transitionTime.value.toDouble().seconds
-                        delay(transitionTime)
-                        hasSwitchedNew.value = false
-                    }
-                    doSwitch()
-                }
-            }
-            currentBeat
-        }
+        val transitionTime = MutableStateFlow(1f)
+        val triggerTime = MutableStateFlow(0.75f)
+        private val switchingLocked = MutableStateFlow(false)
+        val isLocked = switchingLocked.asStateFlow()
 
         private suspend fun doSwitch() {
             // change preset queue
@@ -330,17 +276,17 @@ class Deck(
                 isEnabled,
             ) { (currentBeat, lastBeat), beatFrame, triggerTime, isEnabled ->
                 val triggerAt = triggerTime * beatFrame
-                if (isEnabled && !hasSwitchedNew.value) {
+                if (isEnabled && !switchingLocked.value) {
                     val shouldTrigger =
                         (lastBeat < triggerAt && currentBeat >= triggerAt) || (lastBeat > beatFrame && currentBeat >= triggerAt)
 
                     if (shouldTrigger) {
-                        logger.info { "$deckName triggered at $currentBeat $triggerAt" }
-                        hasSwitchedNew.emit(true)
+                        logger.debug { "$deckName triggered at $currentBeat $triggerAt" }
+                        switchingLocked.emit(true)
                         flowScope.launch {
                             val transitionTime = ndTime.transitionTime.value.toDouble().seconds
                             delay(transitionTime)
-                            hasSwitchedNew.emit(false)
+                            switchingLocked.emit(false)
                         }
                         flowScope.launch {
                             doSwitch()

src/desktopMain/kotlin/osc/OSCUtil.kt

@@ -1,11 +1,7 @@
 package osc
 
-import com.illposed.osc.OSCBadDataEvent
-import com.illposed.osc.OSCBundle
 import com.illposed.osc.OSCMessage
 import com.illposed.osc.OSCPacket
-import com.illposed.osc.OSCPacketEvent
-import com.illposed.osc.OSCPacketListener
 import com.illposed.osc.OSCSerializerAndParserBuilder
 import com.illposed.osc.argument.handler.BlobArgumentHandler
 import com.illposed.osc.argument.handler.BooleanFalseArgumentHandler
@@ -23,43 +19,31 @@ import com.illposed.osc.argument.handler.StringArgumentHandler
 import com.illposed.osc.argument.handler.SymbolArgumentHandler
 import com.illposed.osc.argument.handler.TimeTag64ArgumentHandler
 import com.illposed.osc.argument.handler.UnsignedIntegerArgumentHandler
-import com.illposed.osc.messageselector.OSCPatternAddressMessageSelector
 import com.illposed.osc.transport.OSCPortIn
 import com.illposed.osc.transport.OSCPortInBuilder
 import com.illposed.osc.transport.OSCPortOut
-import com.illposed.osc.transport.OSCPortOutBuilder
 import flowScope
 import io.github.oshai.kotlinlogging.KotlinLogging
-import io.github.xn32.json5k.Json5
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.FlowPreview
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.collectLatest
-import kotlinx.coroutines.flow.consumeAsFlow
-import kotlinx.coroutines.flow.debounce
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.drop
 import kotlinx.coroutines.flow.launchIn
-import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.onEach
-import kotlinx.coroutines.flow.runningFold
 import kotlinx.coroutines.flow.sample
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 import kotlinx.datetime.Clock
 import kotlinx.datetime.Instant
-import kotlinx.serialization.builtins.MapSerializer
-import kotlinx.serialization.builtins.serializer
-import utils.receiveAvailable
-import java.io.File
 import java.net.InetAddress
 import java.net.InetSocketAddress
 import kotlin.time.Duration.Companion.milliseconds
 import kotlin.time.Duration.Companion.minutes
-import kotlin.time.Duration.Companion.seconds
 
 
 private val logger = KotlinLogging.logger { }

src/desktopMain/kotlin/ui/screens/BeatprogressScreen.kt

@@ -98,15 +98,15 @@ fun beatProgressScreen(
         val enabled by deck.isEnabled.collectAsState()
         if(!enabled) return@mapNotNull null
 
-        val hasSwitched by deck.presetSwitching.hasSwitched.collectAsState()
+        val isLocked by deck.presetSwitching.isLocked.collectAsState()
         val triggerTime by deck.presetSwitching.triggerTime.collectAsState()
 
         val transitionTime by deck.ndTime.transitionTime.collectAsState()
         val beatsPerSecond = 60.0f / bpmRounded.toFloat()
         val beatsInTransitionTime = transitionTime / beatsPerSecond
         val sweepAngle = 1.0f / frame * beatsInTransitionTime
 
-        val brush = if (!hasSwitched)
+        val brush = if (!isLocked)
             Brush.sweepGradient(
                 0f to deck.color,
                 sweepAngle*0.2f to deck.dimmedColor,