One more animation: 2024-20 (Race Condition)

* Make the AnimationRecorder drop frames that repeat the last one.
* Add the ability to override specified position in a frame.
* Add an animation for year 2024, day 20, part 1.

Author: rhaendel

animations/2024-20_RaceCondition.gif

@@ -15,3 +15,10 @@ Iteratively, all accessible rolls of paper (those with fewer than four rolls of
 are removed by a forklift.
 
 ![Printing Department animation](2025-04_PrintingDepartment.gif)
+
+### Year 2024, Day 20 - Race Condition, Part 1
+
+After following the (unique) path from start to goal, highlight the positions on that path in red that are starting
+positions for cheats of at most 2 picoseconds length saving at least 10 picoseconds.
+
+![Race Condition animation](2024-20_RaceCondition.gif)

animations/animations.md

@@ -1,18 +1,56 @@
 package de.ronny_h.aoc.extensions.animation
 
 import de.ronny_h.aoc.extensions.asList
+import de.ronny_h.aoc.extensions.grids.Coordinates
 import io.github.oshai.kotlinlogging.KotlinLogging
 import java.awt.Color
 import java.io.File
+import kotlin.math.max
 
-class AnimationRecorder {
+class AnimationRecorder(private val compact: Boolean = false) {
     private val frames = mutableListOf<List<String>>()
     private val logger = KotlinLogging.logger {}
 
+    /**
+     * Records the given [frame]. If the recorder is [compact], frames that are identical with the last recorded frame
+     * get dropped.
+     */
     fun record(frame: String) {
-        frames.add(frame.asList())
+        val newFrame = frame.asList()
+        if (frames.isEmpty() || !compact || frames.last() != newFrame) {
+            frames.add(newFrame)
+        }
     }
 
+    /**
+     * Repeats the last recorded frame while overriding the positions in [overrides] with the [overrideChar].
+     */
+    fun recordLastFrameWithOverrides(overrides: List<Coordinates>, overrideChar: Char) {
+        if (frames.isEmpty()) return
+        frames
+            .last()
+            .mapIndexed { y, line ->
+                line.mapIndexed { x, char ->
+                    if (Coordinates(x, y) in overrides) overrideChar else char
+                }.joinToString("")
+            }
+            .let { frames.add(it) }
+    }
+
+    /**
+     * Repeats the last [nFrames] frames [times] times.
+     */
+    fun repeatLast(nFrames: Int, times: Int) {
+        val toRepeat = frames.subList(max(0, frames.size - nFrames), frames.size).toList()
+        repeat(times) {
+            frames.addAll(toRepeat)
+        }
+    }
+
+    /**
+     * Saves the recorded frames sequence to an animated GIF file named [fileName]. If specified, colors are mapped
+     * according to [colors] and the background gets colored in [background] color.
+     */
     fun saveTo(fileName: String, colors: Map<Char, Color> = emptyMap(), background: Color = purpleBlue) {
         frames
             .map { it.createImage(colors, background) }

src/main/kotlin/de/ronny_h/aoc/extensions/animation/AnimationRecorder.kt

@@ -21,9 +21,11 @@ import javax.imageio.stream.ImageOutputStream
 val green = Color(0, 153, 0)
 val lightGreen = Color(0, 186, 13)
 val purpleBlue = Color(15, 15, 35)
-val lightGrey = Color(204, 204, 204)
+val lightBlue = Color(0, 200, 255)
 val gray = Color(70, 70, 70)
+val lightGrey = Color(204, 204, 204)
 val darkGrey = Color(16, 16, 26)
+val yellow = Color(255, 255, 102)
 
 private const val scale = 1
 private const val fontSize = scale * 20

src/main/kotlin/de/ronny_h/aoc/extensions/animation/GifSequenceWriter.kt

@@ -1,19 +1,40 @@
 package de.ronny_h.aoc.year2024.day20
 
 import de.ronny_h.aoc.AdventOfCode
+import de.ronny_h.aoc.extensions.animation.*
 import de.ronny_h.aoc.extensions.graphs.shortestpath.ShortestPath
 import de.ronny_h.aoc.extensions.graphs.shortestpath.aStar
 import de.ronny_h.aoc.extensions.grids.Coordinates
 import de.ronny_h.aoc.extensions.grids.Direction
 import de.ronny_h.aoc.extensions.grids.Grid
+import de.ronny_h.aoc.year2024.day20.RaceTrack.Companion.EMPTY
+import de.ronny_h.aoc.year2024.day20.RaceTrack.Companion.GOAL
+import de.ronny_h.aoc.year2024.day20.RaceTrack.Companion.SHORTCUT_START
+import de.ronny_h.aoc.year2024.day20.RaceTrack.Companion.START
+import de.ronny_h.aoc.year2024.day20.RaceTrack.Companion.VISITED
+import de.ronny_h.aoc.year2024.day20.RaceTrack.Companion.WALL
+import java.awt.Color.red
 
 fun main() = RaceCondition().run(1438, 1026446)
 
 class RaceCondition : AdventOfCode<Int>(2024, 20) {
     fun part1(input: List<String>, minPicosecondsSaved: Int, shortcutMaxLength: Int): Int {
         val track = RaceTrack(input)
-        track.printGrid()
-        return track.countAllShortcutsSavingAtLeast(minPicosecondsSaved, shortcutMaxLength)
+//        track.recorder = AnimationRecorder()
+//        track.printGrid()
+        val result = track.countAllShortcutsSavingAtLeast(minPicosecondsSaved, shortcutMaxLength)
+        track.recorder?.saveTo(
+            "animations/$year-${paddedDay()}_${javaClass.simpleName}.gif",
+            mapOf(
+                START to green,
+                GOAL to yellow,
+                WALL to lightGrey,
+                EMPTY to gray,
+                VISITED to lightBlue,
+                SHORTCUT_START to red,
+            ),
+        )
+        return result
     }
 
     fun part1Small(input: List<String>) = part1(input, 10, 2)
@@ -24,19 +45,28 @@ class RaceCondition : AdventOfCode<Int>(2024, 20) {
 
 }
 
-private class RaceTrack(input: List<String>) : Grid<Char>(input, '#') {
-    private val wall = nullElement
+private class RaceTrack(input: List<String>) : Grid<Char>(input, WALL) {
+
+    companion object {
+        const val START = 'S'
+        const val GOAL = 'E'
+        const val WALL = '#'
+        const val EMPTY = '.'
+        const val VISITED = 'o'
+        const val SHORTCUT_START = 'x'
+    }
+
     override fun Char.toElementType(): Char = this
 
-    private val start = find('S')
-    private val goal = find('E')
+    private val start = find(START)
+    private val goal = find(GOAL)
 
     fun shortestPath(): ShortestPath<Coordinates> {
         val neighbours: (Coordinates) -> List<Coordinates> = { node ->
             Direction
                 .entries
                 .map { node + it }
-                .filter { get(node) != wall }
+                .filter { get(node) != WALL }
         }
 
         val d: (Coordinates, Coordinates) -> Int = { _, _ ->
@@ -46,7 +76,12 @@ private class RaceTrack(input: List<String>) : Grid<Char>(input, '#') {
 
         val h: (Coordinates) -> Int = { it taxiDistanceTo goal }
 
-        return aStar(start, { this == goal }, neighbours, d, h)
+        return aStar(
+            start, { this == goal }, neighbours, d, h,
+            printIt = { visited, _, _ ->
+                recorder?.record(toString(visited.filter { get(it) == EMPTY }.toSet(), VISITED))
+            }
+        )
     }
 
     fun countAllShortcutsSavingAtLeast(minToSave: Int, shortcutMaxLength: Int): Int {
@@ -61,11 +96,14 @@ private class RaceTrack(input: List<String>) : Grid<Char>(input, '#') {
         fun Coordinates.isShorterToGoalThan(position: Coordinates): Boolean =
             distances.getValue(this) + (this taxiDistanceTo position) <= distances.getValue(position) - minToSave
 
-        return shortestPath.path.flatMap { position ->
+        val shortcutStartPositions = shortestPath.path.flatMap { position ->
             shortestPath
                 .path
-                .filter { it.isInShortcutRangeFrom(position) }
-                .filter { it.isShorterToGoalThan(position) }
-        }.size
+                .filter { position.isInShortcutRangeFrom(it) }
+                .filter { position.isShorterToGoalThan(it) }
+        }
+        recorder?.recordLastFrameWithOverrides(shortcutStartPositions, SHORTCUT_START)
+        recorder?.repeatLast(2, 3)
+        return shortcutStartPositions.size
     }
 }