raindown 0.6.0 → 0.7.0

data/lib/raindown/tui/feelings/feelings_log.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'csv'
+require 'date'
+require 'fileutils'
+require 'open3'
+
+module Raindown
+  module TUI
+    # How a method felt: one of Severance's four tempers, woe, frolic, dread or malice, or numb, with an optional note.
+    Feeling = Data.define(:method, :temper, :note) do
+      # What Claude Code is asked, to fix the method.
+      def prompt
+        "Refactor #{method.label} in #{method.path}:#{method.line}. #{felt} " \
+          "Keep its behaviour, follow the project's CLAUDE.md if it has one, and run the specs."
+      end
+
+      def felt
+        return 'It needs a second look.' unless temper
+
+        "It felt like #{temper}#{": #{note}" if note}."
+      end
+    end
+
+    # The feelings everyone's sorted about the code as it is now, kept in .raindown/feelings.csv with the commit they were
+    # felt at, which a node can count, like the README's code debt. A feeling about code that's since changed, or gone, moves to
+    # .raindown/memories.csv, so the feelings stay few, and the history's kept.
+    class FeelingsLog
+      TEMPERS = %w[frolic hope numb woe dread malice].freeze
+      HEADER = %i[when where method temper note commit checksum].freeze
+      def initialize(root:)
+        @root = root
+        @csv = File.join(root, '.raindown', 'feelings.csv')
+        @memories = File.join(root, '.raindown', 'memories.csv')
+      end
+
+      # Adds the feeling, as the newest, in place of one about the method before, which moves to the memories if it was
+      # about the method's code before it changed.
+      def add(feeling)
+        method = feeling.method
+        row = {
+          when: Date.today.iso8601,
+          where: where(method),
+          method: method.label,
+          temper: feeling.temper,
+          note: feeling.note,
+          commit:,
+          checksum: method.checksum
+        }
+        changed, others = rows.reject { felt_row?(it, method) }.partition { about?(it, method) }
+        append_memories(changed)
+        write_rows(others + [row])
+      end
+
+      # Moves the feelings about methods that have changed, or gone, since they were felt, from the methods there are
+      # now, to the memories. A row from before checksums were kept stays while its method's there.
+      def move_stale_to_memories(methods)
+        now = methods.flat_map { [[relative(it.path), it.label, it.checksum], [relative(it.path), it.label, '']] }.to_set
+        stale, current = rows.partition { !now.include?(key(it)) }
+        return if stale.empty?
+
+        append_memories(stale)
+        write_rows(current)
+      end
+
+      # Read once, and again after a feeling's added.
+      def rows
+        return [] unless File.exist?(@csv)
+
+        @rows ||= CSV.read(@csv, headers: true, header_converters: :symbol).map(&:to_h)
+      end
+
+      # Whether the method's been felt, by its file, name and code's checksum, wherever its line is now. A row from before
+      # checksums were kept has none, so it counts until the method's felt again.
+      def felt?(method)
+        @felt ||= rows.to_set { key(it) }
+        [method.checksum, ''].any? { @felt.include?([relative(method.path), method.label, it]) }
+      end
+
+      # How the method last felt, while its code's the same as when it was felt, or nil.
+      def temper(method) = rows.reverse.find { felt_row?(it, method) }&.fetch(:temper)
+
+      # How many feelings there are of each temper, in the bins' order.
+      def counts
+        tally = rows.map { it[:temper] }.tally
+        TEMPERS.to_h { [it, tally.fetch(it, 0)] }
+      end
+
+      private
+
+      def felt_row?(row, method) = about?(row, method) && [method.checksum, ''].include?(row[:checksum].to_s)
+
+      def about?(row, method) = path(row) == relative(method.path) && row[:method] == method.label
+
+      # The row's file, without the line the method was on.
+      def path(row) = row[:where].sub(/:\d+\z/, '')
+
+      # The row's file, method and checksum, which is empty for a row from before checksums were kept.
+      def key(row) = [path(row), row[:method], row[:checksum].to_s]
+
+      # Adds the rows to the memories, of feelings about code that's since changed or gone.
+      def append_memories(rows)
+        return if rows.empty?
+
+        header = !File.exist?(@memories)
+        CSV.open(@memories, 'a') do |csv|
+          csv << HEADER if header
+          rows.each { csv << it.values_at(*HEADER) }
+        end
+      end
+
+      def write_rows(rows)
+        FileUtils.mkdir_p(File.dirname(@csv))
+        CSV.open(@csv, 'w') do |csv|
+          csv << HEADER
+          rows.each { csv << it.values_at(*HEADER) }
+        end
+        @rows = @felt = nil
+      end
+
+      def where(method) = "#{relative(method.path)}:#{method.line}"
+
+      def relative(path) = path.delete_prefix(File.join(@root, ''))
+
+      def commit
+        sha, status = Open3.capture2('git', '-C', @root, 'rev-parse', '--short', 'HEAD', err: File::NULL)
+        sha.strip if status.success?
+      rescue SystemCallError
+        nil
+      end
+    end
+  end
+end

data/lib/raindown/tui/feelings/feelings_renderer.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require 'zlib'
+
+require_relative '../../stat'
+require_relative '../renderers/renderer'
+require_relative 'bins'
+require_relative 'code_box'
+require_relative 'scene'
+require_relative 'waffle'
+
+module Raindown
+  module TUI
+    # Code feelings, right of the files: the methods as clusters of digits in a grid, with the selected one highlighted
+    # and its code below, then why it felt that way while that's typed, then the six bins and how many each holds.
+    # When the batch is refined, it rains over them, then there's a waffle:
+    #     0  0  2  2  2  5  5  9  9  9  9  1
+    #     1  3  3  7  7  7  6  4  4  0  8  8
+    #    ╭─ lib/text.rb:62 · Text#segments_between ──────────── changed 6× ─╮
+    #    │ def segments_between(line, from, to)                              │
+    #    ╰───────────────────────────────────────────────────────────────────╯
+    #    ╭─ 01 ────╮ ╭─ 02 ────╮ ╭─ 03 ────╮ ╭─ 04 ────╮ ╭─ 05 ────╮ ╭─ 06 ────╮
+    #    │ FROLIC  │ │ HOPE    │ │ NUMB    │ │ WOE     │ │ DREAD   │ │ MALICE  │
+    #    │ ███░  9 │ │ ██░░  5 │ │ ████ 41 │ │ ██░░  6 │ │ █░░░  3 │ │ █░░░  2 │
+    #    ╰─────────╯ ╰─────────╯ ╰─────────╯ ╰─────────╯ ╰─────────╯ ╰─────────╯
+    class FeelingsRenderer < Renderer
+      include Bins
+      include CodeBox
+      include Waffle
+
+      # The columns and lines a cell takes, its digit small on the first line, with room around it for the digit magnified
+      # in a stat's block digits, over the line above and the spaces beside it, when its method's selected or the mouse is
+      # over it.
+      CELL = 6
+      CELL_LINES = 2
+      # The code box's lines of code that a batch is sized for.
+      FILLED_CODE_LINES = 1
+      # The drift from which a method's cells flicker, and the ticks, half a second each, between a cell's flickers.
+      RESTLESS = 7
+      FLICKER_TICKS = 12
+      # How far a cell's digit is from its method's drift, by its roll out of NOISE_ROLL, so about three in ten are off.
+      NOISE = { 0 => -1, 1 => 1, 2 => -1, 3 => 1, 4 => -2, 5 => 2 }.freeze
+      NOISE_ROLL = 20
+      BUTTONS = [['Tab', 'Pane', :tab], ['1-6', 'Feel', nil], ['e', 'Edit', :edit], ['x', 'Fix', :execute],
+                 ['/', 'Search', :search], ['q', 'Quit', :quit]].freeze
+
+      def buttons = BUTTONS
+      def page = 'Code feelings'
+
+      # How much of the batch has been refined, on the right of the line above the panes.
+      def spacer
+        progress = "#{view.batch.progress} "
+        progress_width = display_width(progress)
+        padded([segment('', :blank, width: [width - progress_width, 0].max), segment(progress, :body, width: progress_width)])
+      end
+
+      # The cells come first, as the first draw picks the batch to fill them.
+      def lines
+        cells = view.cells(columns, filled_rows)
+        return instead if view.code_methods.empty? || view.celebration
+
+        below = [*code_box, *bins]
+        (grid(cells, below.length) + below).first(height)
+      end
+
+      private
+
+      def view = navigator.view
+
+      # Instead of the grid, that there's nothing to feel, or rain and fireworks over the pane when the batch is refined,
+      # then a waffle.
+      def instead
+        return blank(" No functions or methods in #{File.basename(navigator.root)} to feel") if view.code_methods.empty?
+        return Scene.new(width:, height:).lines(view.celebration.frame) if view.animating?
+
+        waffle
+      end
+
+      # The rows of the grid around the selected method's, each its cells' lines, below a blank line that leaves the first
+      # row room to be magnified, above the lines below it, and blank lines for any left over.
+      def grid(cells, below)
+        lines = [height - below, 0].max
+        rows = [(lines - 1) / CELL_LINES, 0].max
+        first = first_row(cells, columns, rows)
+        grid = magnified([padded([]), *grid_rows(cells, first, rows)], cells, first, rows)
+
+        [*grid, *Array.new(lines - grid.length) { padded([]) }].first(lines)
+      end
+
+      # The cells' lines of the rows from the first.
+      def grid_rows(cells, first, rows)
+        Array.new(rows * CELL_LINES) { grid_line(cells, (first + (it / CELL_LINES)) * columns, columns, it % CELL_LINES) }
+      end
+
+      # The lines with the digits of the selected method, and the one the mouse is over, magnified, over the line above them
+      # and beside them, each across its whole cell and the line above it.
+      def magnified(lines, cells, first, rows)
+        magnified_cells(cells, first, rows).each do |index, click|
+          magnify_cell(lines, ((index / columns) - first) * CELL_LINES, cells[index], index, click)
+        end
+        lines
+      end
+
+      # The cell's digit magnified over the lines from the top one, across the whole cell.
+      def magnify_cell(lines, top, owner, index, click)
+        style = magnified_style(owner)
+        Stat::DIGITS[digit(owner, index).to_s].each_with_index do |text, line|
+          magnify(lines, top + line, segment(" #{text}  ", style, width: CELL, event: click), 1 + (index % columns * CELL))
+        end
+      end
+
+      # The selected method's cells, across the whole of each, on the selection's blue, so they join into one block.
+      def magnified_style(owner)
+        return :selected if owner == view.cursor
+
+        :feelings
+      end
+
+      # The cells of the rows from the first that are the selected method's, or the one the mouse is over's, with its click,
+      # unless they're blank.
+      def magnified_cells(cells, first, rows)
+        (first * columns...(first + rows) * columns).filter_map do |index|
+          owner = cells[index]
+          click = Click.new(pane:, index: owner, action: :focus)
+          [index, click] if owner && (owner == view.cursor || navigator.hovered == click) && !hidden?(owner)
+        end
+      end
+
+      def magnify(lines, line, segment, column)
+        lines[line] = overlay_segments(lines[line], [segment], column:)
+      end
+
+      def columns = [(width - 1) / CELL, 1].max
+
+      # The grid's rows with a code box of FILLED_CODE_LINES, between its top and bottom, which a batch fills. A taller box
+      # takes rows from the grid, which then scrolls to keep the selected method in view.
+      def filled_rows = [(height - BIN_LINES - 3 - FILLED_CODE_LINES) / CELL_LINES, 1].max
+
+      # The first row that shows, with the selected method's row in the middle where there's room.
+      def first_row(cells, columns, rows)
+        last = [((cells.length - 1) / columns) - rows + 1, 0].max
+        ((cells.index(view.cursor).to_i / columns) - (rows / 2)).clamp(0, last)
+      end
+
+      # The cells' line of the row from the index.
+      def grid_line(cells, from, columns, line)
+        segments = (from...(from + columns)).filter_map do |index|
+          owner = cells[index]
+          next unless owner
+
+          click = Click.new(pane:, index: owner, action: :focus)
+          segment(cell_text(owner, index, line), :feelings, width: CELL, event: click)
+        end
+        padded([segment('', :blank, width: 1), *segments])
+      end
+
+      # The cell's line: its digit small on the first, or blank once its method's felt, but still there to select, which
+      # shows it again with its code.
+      def cell_text(owner, index, line)
+        return ' ' * CELL if hidden?(owner) || line.nonzero?
+
+        "  #{digit(owner, index)}   "
+      end
+
+      # Whether the method's felt, and not selected, so its cells are blank.
+      def hidden?(owner) = owner != view.cursor && view.batch.felt?(view.code_methods[owner])
+
+      # Near the method's drift, from 0 to 9: a cell's checksum rolls a small chance of it being one or two away.
+      # A heavy method's cells also flicker one lower now and then, each at its own time, so they look restless.
+      def digit(owner, index)
+        drift = view.code_methods[owner].drift
+        seed = Zlib.crc32("#{owner}:#{index}")
+        digit = (drift + NOISE.fetch(seed % NOISE_ROLL, 0)).clamp(0, 9)
+        return digit if drift < RESTLESS || ((view.tick + seed) % FLICKER_TICKS).nonzero?
+
+        digit - 1
+      end
+
+      def blank(message)
+        [[segment(message, :feelings)], *Array.new([height - 1, 0].max) { [segment('', :blank)] }].first(height)
+      end
+    end
+  end
+end

data/lib/raindown/tui/feelings/feelings_view.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require_relative '../events'
+require_relative 'celebration'
+require_relative 'code_methods'
+require_relative 'feelings_log'
+require_relative 'weekly_batch'
+
+module Raindown
+  module TUI
+    # Code feelings, like Severance's macrodata refinement: the project's functions and methods, in any language,
+    # as clusters of digits in a grid, where long methods, and ones whose files keep changing, drift. The cursor moves
+    # between them, the selected one's code shows below the grid, its first lines or with Enter all that fits, and 1 to 6
+    # sort how it feels into a bin: frolic, hope, numb, woe, dread or malice, which notes it down in the FeelingsLog,
+    # staying on it. Woe, dread and malice ask why first, typed until Enter, or Esc to leave it out. E opens the method in the
+    # editor, and X asks Claude Code to fix it, and either way it's read again after, to be felt again.
+    class FeelingsView
+      # Best to worst, as CodeHealth scores them, so the keys rate the code.
+      BINS = { bin1: 'frolic', bin2: 'hope', bin3: 'numb', bin4: 'woe', bin5: 'dread', bin6: 'malice' }.freeze
+      # The tempers that ask why.
+      NOTED = %w[woe dread malice].freeze
+      # Its own keys, besides the bins: Enter and Space show all of the selected method's code, or its first lines again.
+      # Ctrl+T celebrates, to try the rain and the waffle, and isn't shown with the buttons.
+      KEYS = %i[up down left right edit execute tick enter toggle expand celebrate].freeze
+
+      # The temper being noted, and the note typed so far, while it's asking why, whether the selected method's code
+      # shows all that fits, until another's selected, and the rain then the waffle, once the batch is refined.
+      attr_reader :noting, :note, :cursor, :tick, :log, :expanded, :celebration
+
+      def initialize(root:)
+        @root = root
+        @log = FeelingsLog.new(root:)
+        @last_feelings = {}
+        @cursor = 0
+        @tick = 0
+        @week = WeeklyBatch.new(log: @log)
+      end
+
+      def renderer = FeelingsRenderer
+      def target = self
+      # It shows Ruby code, which isn't written back.
+      def path = nil
+      def changed? = false
+      def typing? = !noting.nil?
+      def animating? = celebration&.raining? == true
+      def status(_navigator) = [:info, "This week's code to feel, #{batch.week}"]
+
+      # Reads the code again, keeping the batch, like after a method's edited or fixed, and the selected method, by its
+      # file and name, even when the methods around it change, moving the feelings about code that's changed, or gone, to
+      # the memories.
+      def load
+        was = selected
+        every = CodeMethods.list(@root)
+        @log.move_stale_to_memories(every)
+        @week.read(every)
+        self.cursor = code_methods.index { [it.path, it.label] == [was&.path, was&.label] } || @cursor
+      end
+
+      # The Batch of files whose methods are in the grid.
+      def batch = @week.batch
+      def code_methods = batch.code_methods
+
+      def selected = code_methods[@cursor]
+
+      def cursor=(index)
+        index = index.clamp(0, [code_methods.length - 1, 0].max)
+        @expanded = false unless index == @cursor
+        @cursor = index
+      end
+
+      # Each cell's method, by its index, in reading order, in a grid as many cells across as the columns.
+      # They're kept, so up and down move a row.
+      # The first time the grid's drawn, with its rows, right after the view opens, the batch is picked to fill them.
+      def cells(columns, rows = nil)
+        @week.fill(columns * rows) if rows
+        @columns = columns
+        @cells = code_methods.each_with_index.flat_map { |method, index| [index] * method.size }
+      end
+
+      # Every key while it's asking why or celebrating, and otherwise its own, but Tab to the files, or left from the
+      # first method.
+      def next_step?(key)
+        return true if typing? || celebration
+
+        (KEYS.include?(key) || BINS.key?(key)) && !(key == :left && @cursor.zero?)
+      end
+
+      def next_step(key)
+        return note_step(key) if typing?
+        return @celebration = nil if celebration&.over?(key)
+        return (@tick += 1).then { nil } if key == :tick
+        return (@celebration = Celebration.new).then { nil } if key == :celebrate
+        return unless selected
+        return feel(BINS[key]) if BINS.key?(key)
+
+        method_step(key)
+      end
+
+      private
+
+      # Moves between the methods, or acts on the selected one.
+      def method_step(key)
+        case key
+        when :left then move(-1)
+        when :right then move(1)
+        when :up then move_row(-1)
+        when :down then move_row(1)
+        when :edit then Edit.new(path: selected.path, line: selected.line)
+        when :execute then fix
+        when :enter, :toggle, :expand then (@expanded = !@expanded).then { nil }
+        end
+      end
+
+      # Asks to fix the method, with how it last felt, by its file and name, which stay the same when its lines change.
+      def fix = Fix.new(feeling: @last_feelings[[selected.path, selected.label]] || Feeling.new(method: selected, temper: nil, note: nil))
+
+      def move(by)
+        self.cursor = @cursor + by
+        nil
+      end
+
+      # To the method in the cell above or below the selected one's first cell.
+      def move_row(by)
+        cell = @cells[@cells.index(@cursor).to_i + (by * @columns)]
+        self.cursor = cell if cell
+        nil
+      end
+
+      # Frolic and numb are noted down straight away, while the rest ask why first.
+      def feel(temper)
+        return note_down(temper, nil) unless NOTED.include?(temper)
+
+        @noting = temper
+        @note = +''
+        nil
+      end
+
+      def note_step(key)
+        case key
+        when Type then @note << key.text
+        when :backspace then @note.chop!
+        when :enter then return note_down(@noting, (@note unless @note.strip.empty?))
+        when :escape then return note_down(@noting, nil)
+        end
+        nil
+      end
+
+      # Notes the feeling down, staying on the method, so it can be fixed with what was just said about it. It rains
+      # when that refines the batch.
+      def note_down(temper, note)
+        feeling = Feeling.new(method: selected, temper:, note:)
+        @last_feelings[[selected.path, selected.label]] = feeling
+        @noting = nil
+        refined = batch.refined?
+        @log.add(feeling)
+        @celebration = Celebration.new if !refined && batch.refined?
+        Felt.new(feeling:)
+      end
+    end
+  end
+end

data/lib/raindown/tui/feelings/fireworks.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'zlib'
+
+require_relative 'rain'
+
+module Raindown
+  module TUI
+    # Fireworks, like over the Rain when a batch of code feelings is refined: rockets rising from the bottom, a row a
+    # tick, that burst in a bright colour into sparks flying out eight ways, which fade, then another rises in their
+    # place. Sparks fly twice as far across as up or down, as the cells are about twice as tall as they're wide:
+    #     ·   ·   ·
+    #      +  +  +
+    #       * * *
+    #   · + * * * + ·
+    #       * * *
+    #      +  +  +
+    #     ·   ·   ·
+    #         ╵
+    #         ·
+    class Fireworks
+      # The columns for each rocket in the air at once.
+      COLUMNS_A_ROCKET = 20
+      # The sparks, a frame each, as they fly out from one in the middle and fade.
+      SPARKS = %w[* * * + + · ·].freeze
+      # The eight ways sparks fly, as columns and rows a frame.
+      WAYS = [[-2, -1], [0, -1], [2, -1], [-2, 0], [2, 0], [-2, 1], [0, 1], [2, 1]].freeze
+      # Where a rocket rises, the row it bursts on, and its colour.
+      Rocket = Data.define(:column, :top, :color)
+
+      attr_reader :width, :height
+
+      def initialize(width:, height:)
+        @width = width
+        @height = height
+      end
+
+      # Draws the rockets and bursts at the tick into a Scene's cells, each rocket a tick apart from the others by a
+      # checksum of it.
+      def draw(cells, tick)
+        [width / COLUMNS_A_ROCKET, 1].max.times do |rocket|
+          launch, frame = (tick + Zlib.crc32("rocket #{rocket}")).divmod(height + SPARKS.length)
+          firework(cells, rocket(Zlib.crc32("rocket #{rocket} #{launch}")), frame)
+        end
+      end
+
+      private
+
+      # A rocket, from the seed, a checksum of it and how many it's launched, bursting in the top half or so.
+      def rocket(seed)
+        Rocket.new(column: seed % width, top: (height / 5) + ((seed >> 8) % [height / 3, 1].max),
+                   color: Rain::COLORS[(seed >> 16) % Rain::COLORS.length])
+      end
+
+      # The rocket rising, with a spark trailing it, or once it's as high as it goes, bursting.
+      def firework(cells, rocket, frame)
+        rising = height - 1 - rocket.top
+        return burst(cells, rocket, frame - rising) if frame >= rising
+
+        put(cells, rocket.column, height - 1 - frame, '╵', rocket.color)
+        put(cells, rocket.column, height - frame, '·', rocket.color)
+      end
+
+      def burst(cells, rocket, frame)
+        return unless (spark = SPARKS[frame])
+
+        WAYS.each { |across, down| put(cells, rocket.column + (across * frame), rocket.top + (down * frame), spark, rocket.color) }
+      end
+
+      def put(cells, column, row, char, color)
+        cells[row][column] = [char, color] if row.between?(0, height - 1) && column.between?(0, width - 1)
+      end
+    end
+  end
+end

data/lib/raindown/tui/feelings/rain.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'zlib'
+
+module Raindown
+  module TUI
+    # Rain, like when a batch of code feelings is refined: drops falling down some of the columns, each at its own speed
+    # and in a bright colour of its own, that splash and spread when they hit the bottom, then fall again from the top
+    # in another colour:
+    #       │          ╎
+    #       ╎    │          │
+    #     │     ╎        │
+    #    · ·   ◦       .   .
+    class Rain
+      # One column in RAINY has a drop.
+      RAINY = 4
+      # The splash, a frame each after a drop hits the bottom, as its distance either side of the drop's column.
+      SPLASH = [[0, '◦'], [1, '·'], [2, '.']].freeze
+      COLORS = %i[bright_red bright_orange bright_yellow bright_green bright_cyan bright_blue bright_purple bright_pink].freeze
+
+      attr_reader :width, :height
+
+      def initialize(width:, height:)
+        @width = width
+        @height = height
+      end
+
+      # Draws the drops at the tick into a Scene's cells.
+      def draw(cells, tick)
+        width.times { drop(cells, it, Zlib.crc32("rain #{it}"), tick) }
+      end
+
+      private
+
+      # The column's drop, if it has one, from the seed, a checksum of the column, like how fast it falls and when it
+      # starts.
+      def drop(cells, column, seed, tick)
+        return unless (seed % RAINY).zero?
+
+        falling = (height + speed(seed) - 1) / speed(seed)
+        fallen, frame = (tick + (seed >> 8)).divmod(falling + SPLASH.length)
+        color = color(column, fallen)
+        return splash(cells, column, frame - falling, color) if frame >= falling
+
+        fall(cells, column, frame * speed(seed), color)
+      end
+
+      # A row or two a tick.
+      def speed(seed) = ((seed >> 4) % 2) + 1
+
+      # A colour each time the column's drop falls, from a checksum of how many times it has.
+      def color(column, fallen) = COLORS[Zlib.crc32("#{column} #{fallen}") % COLORS.length]
+
+      # The drop at the row, and its tail above it.
+      def fall(cells, column, row, color)
+        cells[row][column] = ['│', color]
+        cells[row - 1][column] = ['╎', color] if row.positive?
+      end
+
+      def splash(cells, column, frame, color)
+        spread, char = SPLASH[frame]
+        [column - spread, column + spread].uniq.each { cells[height - 1][it] = [char, color] if it.between?(0, width - 1) }
+      end
+    end
+  end
+end

data/lib/raindown/tui/feelings/scene.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../text'
+require_relative 'fireworks'
+require_relative 'rain'
+
+module Raindown
+  module TUI
+    # Animations drawn over each other, each into the same cells, a character and its style each, in turn, so the later
+    # ones are on top, like Fireworks over the Rain.
+    class Scene
+      include Text
+
+      attr_reader :width, :height
+
+      def initialize(width:, height:, animations: [Rain, Fireworks])
+        @width = width
+        @height = height
+        @animations = animations.map { it.new(width:, height:) }
+      end
+
+      # The lines at the tick, as segments.
+      def lines(tick)
+        cells = Array.new(height) { Array.new(width) { [' ', :blank] } }
+        @animations.each { it.draw(cells, tick) }
+        cells.map { segments(it) }
+      end
+
+      private
+
+      # The row's runs of cells in the same style, a segment each.
+      def segments(row)
+        row.chunk_while { |cell, after| cell[1] == after[1] }.map { Segment.new(text: it.map(&:first).join, style: it[0][1], event: nil) }
+      end
+    end
+  end
+end