Fix issues with advancement progress in the assistant

Author: bnorm

storyboard-core/src/commonMain/kotlin/dev/bnorm/storyboard/core/StoryboardState.kt

@@ -64,17 +64,20 @@ class StoryboardState(
     var targetIndex: Storyboard.Index by mutableStateOf(currentIndex)
         private set
 
-    val advancementProgress: Float
+    val advancementDistance: Float
         get() {
             if (currentIndex == targetIndex) return 1f
+            val start = byIndex.getValue(currentIndex).frameIndex
+            val target = byIndex.getValue(targetIndex).frameIndex
+            return abs(target - start).toFloat()
+        }
 
-            val start = byIndex.getValue(currentIndex)
+    val advancementProgress: Float
+        get() {
+            if (currentIndex == targetIndex) return 1f
+            val start = byIndex.getValue(currentIndex).frameIndex
             val current = frameIndex.currentState
-            val target = byIndex.getValue(targetIndex)
-
-            val progress = abs(current - start.frameIndex)
-            val distance = abs(target.frameIndex - start.frameIndex)
-            return progress + (frameIndex.fraction / distance)
+            return abs(current - start) + frameIndex.fraction
         }
 
     // TODO manage scope + job + launch internally? or have utilities for it?
@@ -101,8 +104,8 @@ class StoryboardState(
         } else {
             // Reverse directions.
             val tmp = currentIndex
-            targetIndex = currentIndex
-            currentIndex = tmp
+            currentIndex = targetIndex
+            targetIndex = tmp
 
             frameIndex.animateTo(frameIndex.currentState)
         }

storyboard-easel/src/commonMain/kotlin/dev/bnorm/storyboard/easel/notes/ShowAssist.kt

@@ -33,21 +33,25 @@ fun StoryboardNotes(storyboard: StoryboardState, notes: StoryboardNotes, modifie
             }
 
             Row(modifier = Modifier.fillMaxWidth().padding(top = 16.dp)) {
-                val currentIndex = storyboard.currentIndex
                 Column(modifier = Modifier.weight(1f), horizontalAlignment = Alignment.CenterHorizontally) {
                     Text("Current Frame")
-                    ClickableScenePreview(storyboard, currentIndex)
+                    ClickableScenePreview(storyboard, storyboard.currentIndex)
                     SceneAnimationProgressIndicator(storyboard)
                 }
                 Spacer(Modifier.width(16.dp))
                 Column(modifier = Modifier.weight(1f), horizontalAlignment = Alignment.CenterHorizontally) {
                     Text("Next Frame")
-                    val targetIndex = storyboard.targetIndex
-                    if (targetIndex != currentIndex) {
-                        ClickableScenePreview(storyboard, targetIndex)
-
+                    val nextIndex by derivedStateOf {
+                        val i = storyboard.storyboard.indices.binarySearch(storyboard.currentIndex)
+                        require(i >= 0) { "targetIndex not found in storyboard" }
+                        storyboard.storyboard.indices.getOrNull(i + 1)
+                    }
+                    nextIndex?.let {
+                        ClickableScenePreview(storyboard, it)
                     }
                 }
+                // TODO previous frame?
+                // TODO highlight frame which is being advanced to?
             }
 
             if (notes.tabs.isNotEmpty()) {
@@ -111,11 +115,22 @@ private fun ClickableScenePreview(
 @Composable
 private fun SceneAnimationProgressIndicator(storyboard: StoryboardState) {
     Row {
+        val advancementDistance = storyboard.advancementDistance
         val advancementProgress = storyboard.advancementProgress
-        val color = if (advancementProgress == 1f) Color.Green else Color.Red
-        Spacer(Modifier.height(2.dp).weight(advancementProgress).background(color))
-        if (advancementProgress < 1f) {
-            Spacer(Modifier.weight(1f - advancementProgress))
+        when {
+            advancementProgress == advancementDistance -> {
+                Spacer(Modifier.height(2.dp).weight(1f).background(Color.Green))
+            }
+
+            else -> {
+                val complete = advancementProgress.toInt() / advancementDistance
+                val partial = (advancementProgress % 1f) / advancementDistance
+                val remaining = 1f - complete - partial
+
+                if (complete > 0f) Spacer(Modifier.height(2.dp).weight(complete).background(Color.Green))
+                if (partial > 0f) Spacer(Modifier.height(2.dp).weight(partial).background(Color.Red))
+                if (remaining > 0f) Spacer(Modifier.height(2.dp).weight(remaining).background(Color.DarkGray))
+            }
         }
     }
 }