dopairb 0.1.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e71c4e0e91c35575f8ac0ebc641873bc4fc5af8dfc78b3ab4b17aa2b9ab3057
-  data.tar.gz: df276b5e5997edf7eaf128f022c6475a39b8db2949317e64db718bc8c91bf15a
+  metadata.gz: cbc57c42e0e25caed6e783bf761e9edda9822c1d853fa4d55c144ce6704a875e
+  data.tar.gz: a3d81e85abe05052cbbf99907162215b4d27796fd0ed14827d83190c0252672e
 SHA512:
-  metadata.gz: 1fed2568ae4137a3da8d88c4d7ce74cf79ec6fba2f82d5d823a5cae1e063f91d35363910f7b68e3e154de0491b249e6125c1eea72c45fd6d399ed0b86244c055
-  data.tar.gz: 7a117f3e7a8ae10726a56b3469c8580fe7e68e0a1cad2a4c1b145ea8e480ff35d1a90ccd14e37a249e3078da1d095998b1c55c0e14ddd56ed1ae3e3917493387
+  metadata.gz: 9522cb64cb142280f6ed6070e0e92884206fb0a7eccd1d289202c64ed9cb28a2cbb14d291a686362ce5797654910dec25f91ab2383193e82782cbd9bcceb7943
+  data.tar.gz: 6cae99bcfcdcf7419a2e943fda49cbb97f8603a7e7a09d17f23bf5beb165b8ab85e6cea0f99c6d20f0daa6304dcb13341c5ef9f2781e635642003a4e6dd4f11f

data/README.md

@@ -3,6 +3,10 @@
 An interactive Ruby shell that answers every keystroke, evaluation, result and exception with loud terminal effects.
 It is built as an IRB extension. The design spec is [spec.md](spec.md) (in Japanese).
 
+https://github.com/user-attachments/assets/b45e4a97-ffde-4fb2-be73-ef69d5c8af42
+
+A 70-second session with sound (`dopairb`, the defaults); also in [docs/dopairb-demo.mp4](docs/dopairb-demo.mp4). The scripts that recorded it are in [docs/recording](docs/recording).
+
 ```
 dopairb(main):001> (1..100).sum                     COMBO 00  SCORE 33  [⣿⣿⣀⣀⣀⣀⣀⣀] x1.5
                     ⠂⠌⠟⠃        <- sparks, afterglow and HUD on every keystroke
@@ -29,21 +33,29 @@ To try it without installing, run `ruby exe/dopairb` in the checkout.
 ## Usage
 
 ```console
-$ dopairb                 # start it (IRB options are passed through)
+$ dopairb                 # start it, at full blast with sound (IRB options are passed through)
 $ dopairb --calm          # quieter: low intensity, no flash, shorter effects
-$ dopairb --max           # everything at maximum; the biggest moments go full screen
-$ dopairb --party         # max + full-screen flash + bell
+$ dopairb --party         # max + full-screen flash + sound effects
+$ dopairb --intensity=normal --no-sound   # the tamer pre-0.4.0 defaults
 $ dopairb --no-flash      # suppress flashing, available from the very first start
 $ DOPAIRB="intensity=low,flash=off" dopairb
 ```
 
-To enable it in your regular `irb`, add this to `~/.irbrc`:
+To turn your regular `irb` into dopairb, add this to `~/.irbrc`:
 
 ```ruby
-require "dopairb"
-Dopairb.enable            # also e.g. Dopairb.enable(flash: :off, intensity: :low)
+begin
+  require "dopairb"
+  Dopairb.enable          # also e.g. Dopairb.enable(sound: :off, intensity: :normal)
+rescue LoadError
+  # a Ruby without dopairb keeps plain irb
+end
 ```
 
+The title (and the loading screen on a cold start) plays right before the first prompt, as with the `dopairb` command.
+Sessions opened by `binding.irb` get the effects too; `Dopairb.enable(binding_irb: false)` keeps them plain.
+Settings for a single run (`dopairb` options and `$DOPAIRB`) win over the ones given to `Dopairb.enable` in `.irbrc`.
+
 Inside a session, the `dopa` command changes settings:
 
 ```
@@ -51,6 +63,9 @@ dopa                  show settings and session stats
 dopa off|low|normal|max
 dopa calm / dopa party
 dopa demo             play every effect once (does not change your score)
+dopa loading          show the loading screen
+dopa gallery          the bonus art you have collected (`dopa gallery starry_night` shows one)
+dopa gallery tour     a full-screen slideshow of all 100; uncollected ones appear as silhouettes
 dopa flash=off duration=0.5 ...
 ```
 
@@ -58,10 +73,10 @@ dopa flash=off duration=0.5 ...
 
 | Setting | Values | Default | Meaning |
 | --- | --- | --- | --- |
-| `intensity` | off / low / normal / max | normal | Overall amount. `off` behaves exactly like plain IRB |
+| `intensity` | off / low / normal / max | max | Overall amount. `off` behaves exactly like plain IRB |
 | `motion` | on / off | on | `off` disables animation (badges only) |
 | `flash` | off / soft / full | soft | `soft` flashes only the effect area, `full` inverts the whole screen |
-| `sound` | on / off | off | Terminal bell on big moments |
+| `sound` | off / bell / sfx | sfx | `sfx` plays synthesized sound effects, `bell` rings the terminal bell on big moments |
 | `hud` | on / off | on | COMBO / SCORE / CHARGE on the right of the prompt line |
 | `duration` | 0.1–5 | 1.0 | Length multiplier for every effect |
 | `color` | auto / truecolor / 256 / 16 / none | auto | `none` when `NO_COLOR` is set |
@@ -69,6 +84,7 @@ dopa flash=off duration=0.5 ...
 | `charge` | 0–0.3 s | 0.12 | Wind-up before a fast result lands; 0 disables it |
 | `intro` | on / off | on | Title animation at startup |
 | `keys` | on / off | on | Per-keystroke effects |
+| `binding_irb` | on / off | on | Effects in sessions opened by `binding.irb` too |
 
 ## Effects
 
@@ -78,6 +94,7 @@ When several fire at once, only the biggest plays. The smaller ones are folded i
 | Moment | Effect |
 | --- | --- |
 | Typing | A spark trail right of the cursor, a brief glow on the typed character, embers falling below, a x1.0–x3.0 multiplier |
+| Typing streak of 8, 16, 32 … 1024 keys | Powers of two, in big half-block letters under the input: `8-BIT RUSH!`, `16-BIT COMBO!`, `32-BIT BLAZE!!`, `64-BIT OVERDRIVE!!`, `128-BIT HYPER MODE!!`, `0x100 OVERFLOW!!!`, `2^9 GODSPEED!!!`, `1KiB TYPING LEGEND!!!`, with a bonus of 4 points per key |
 | Resuming after a pause | Reignites with `CHARGE!` |
 | Backspace / Delete | The deleted character shatters and falls. The next keystroke shows `RECOVERY` |
 | Cursor movement | A light streak in the direction of travel |
@@ -102,12 +119,48 @@ When several fire at once, only the biggest plays. The smaller ones are folded i
 | Other exceptions | A red flash and a glitching `FAILED` |
 | Ctrl-C | The stored charge scatters, `INTERRUPTED` |
 | First eval / COMBO 5, 10, 25… / eval count 10, 50, 100… | `FIRST HIT!` / `COMBO 10!` / `100 EVALS` |
+| Lucky success (about 1 in 10, up to 1 in 5 with a full CHARGE) | `CRITICAL!!`: a slash, a red flash and x2 / x4 / x8 points |
+| Very lucky success (1 in 67) | `JACKPOT!!`: three slot reels stop on 7-7-7, coins rain, x16 points |
+| COMBO 10 and beyond | `FEVER TIME!`: every point counts double until the next error; the HUD glows in rainbow `FEVER!` |
+| Beating your all-time best combo | `BEST COMBO!` |
+| Level up, jackpot, or a lucky drop (see [Career](#career)) | `LEVEL UP!` / `JACKPOT PRIZE` / `ART DROP!`, then a famous painting is unveiled full screen as bonus art |
 | Numeric record (more than doubled) | `NEW RECORD` |
 | Success right after an error | `FIXED!` (after one error) / `COMEBACK!` (after a streak), both huge |
-| Exit | A result screen that counts up, left behind as a plain table |
+| Exit | A full-screen finale: the title drops, stats slam in one by one, the total score counts up under a drum roll, a rank is stamped (S/A/B/C with a cheerful title), then fireworks. The result is left behind as a plain table |
 
 Error effects name the kind of error. They never make fun of the failure.
 
+## Career
+
+Between sessions dopairb keeps a small profile: lifetime XP (the sum of your scores), level, best score, best combo, a day streak and the bonus art you have collected.
+Levels need powers of two: LV 2 at 512 XP, LV 3 at 1,024, LV 4 at 2,048, and so on.
+Each level-up and each jackpot unveils a masterpiece full screen, and now and then (about 1 success in 50) one simply drops: `ART DROP!`. There are 100 public-domain works to collect, from the Lascaux horses and Hokusai's *Great Wave* through Vermeer, Turner and van Gogh to Klimt, Kandinsky and Mondrian, all painted procedurally in half blocks (no image files ship with the gem). New ones come first; `dopa gallery` lists yours. (Spoilers: all 100 are in [docs/gallery.png](docs/gallery.png).)
+The startup title shows your level and day streak, and the finale shows `NEW BEST!` and an XP bar.
+
+The profile is `~/.local/state/dopairb/profile.json` (`$XDG_STATE_HOME` is honored). Set `DOPAIRB_PROFILE=path` to use another file, or `DOPAIRB_PROFILE=off` to keep nothing; levels are then not shown.
+Non-interactive runs never touch it.
+
+`DOPAIRB_SEED=n` makes the luck (critical hits, jackpots, particles) repeatable, which helps when recording a demo.
+
+## Sound
+
+With `sound=sfx`, every effect has a sound: key clicks, `NICE!` chimes, a comet ping, a stamp thump, a count-up that ends in a boom, fanfares and explosions for the big moments, a buzz or crack for errors.
+All sounds are synthesized in Ruby at runtime and cached as WAV files in the temp directory. No audio files ship with the gem.
+
+They are played by the first player found:
+
+- `paplay` (PulseAudio, including WSLg on WSL2)
+- `afplay` (macOS)
+- `aplay` (ALSA)
+- `powershell.exe` on WSL without WSLg
+
+The finale's sound is one track synthesized on the same timeline as the animation (a tick and a rising note per stat row, a drum roll, a boom, a fanfare, fireworks) and stretched with `duration`.
+Sounds are rendered once and reused by later sessions. At startup, a Ractor renders the missing ones in parallel with the REPL, so typing is not slowed down (a thread is used where Ractor is unavailable). The startup sound is rendered first. On a start without cached sounds (the first run, or after an upgrade), a loading screen (a cat running along a pastel progress bar) is shown until it is ready. `dopa loading` shows it any time.
+Players run as separate processes, so the REPL never waits for them.
+PowerShell takes a few hundred milliseconds to start, so with it only the result effects make sound, not every keystroke.
+When no player is found, `sfx` falls back to the terminal bell on big moments.
+Sound plays on the machine that runs dopairb, so over ssh you will not hear it.
+
 ## Readable, never broken
 
 - IRB evaluates and prints as usual. `=> value`, exception messages and backtraces come from IRB itself.
@@ -151,7 +204,7 @@ The rest is terminal-independent logic:
 - Scores live for the session only and are not saved.
 - Effects use Unicode. Any glyph that is not one column wide is swapped for ASCII or braille at runtime.
 - Start it with the `dopairb` command, or call `Dopairb.enable` in `.irbrc`.
-- IRB sessions entered via `binding.irb` get the same Context hook. The result screen appears only when the outermost session ends.
+- IRB sessions entered via `binding.irb` get the same Context hook (unless `binding_irb=off`; detected with `IRB::Context#from_binding?`). The result screen appears only when the outermost session ends.
 
 ## Performance
 

data/lib/dopairb/canvas.rb

@@ -120,39 +120,48 @@ module Dopairb
       @bold[y][x] = bold
     end
 
+    BRAILLE_CHARS = Array.new(256) { |i| (0x2800 + i).chr(Encoding::UTF_8) }.freeze
+
     def render_row(y, depth, shake)
       chs = @ch[y]
+      fgs = @fg[y]
+      bgs = @bg[y]
+      bolds = @bold[y]
+      dots = @dots[y]
+      dotc = @dotc[y]
+      utf8 = Term.utf8?
       last = @w - 1
-      last -= 1 while last >= 0 && chs[last].nil? && @dots[y][last] == 0 && @bg[y][last].nil?
+      last -= 1 while last >= 0 && chs[last].nil? && dots[last] == 0 && bgs[last].nil?
       out = +""
-      cur = nil
-      if shake > 0
-        out << (" " * shake)
-      end
-      start = shake < 0 ? -shake : 0
+      out << (" " * shake) if shake > 0
+      x = shake < 0 ? -shake : 0
       limit = shake > 0 ? [last, @w - 1 - shake].min : last
-      x = start
+      cur = nil
       while x <= limit
         c = chs[x]
         if c == CONT
           x += 1
           next
         end
-        fg = @fg[y][x]
-        bold = @bold[y][x]
+        fg = fgs[x]
+        bg = bgs[x]
+        bold = bolds[x]
         if c.nil?
-          if @dots[y][x] != 0
-            c = Term.utf8? ? (0x2800 + @dots[y][x]).chr(Encoding::UTF_8) : "."
-            fg = @dotc[y][x]
+          d = dots[x]
+          if d != 0
+            c = utf8 ? BRAILLE_CHARS[d] : "."
+            fg = dotc[x]
             bold = false
           else
             c = " "
+            fg = nil
+            bold = false
           end
         end
-        style = [fg, @bg[y][x], bold]
-        if style != cur
-          out << (depth == :none && !bold && @bg[y][x].nil? ? "\e[0m" : Color.sgr(fg, @bg[y][x], bold, depth))
-          cur = style
+        key = style_key(fg, bg, bold)
+        if key != cur
+          out << sgr_for(key, fg, bg, bold, depth)
+          cur = key
         end
         out << c
         x += 1
@@ -160,5 +169,19 @@ module Dopairb
       out << "\e[0m" if cur
       out
     end
+
+    def style_key(fg, bg, bold)
+      f = fg ? (fg[0] << 16) | (fg[1] << 8) | fg[2] : 0x1000000
+      b = bg ? (bg[0] << 16) | (bg[1] << 8) | bg[2] : 0x1000000
+      (f << 26) | (b << 1) | (bold ? 1 : 0)
+    end
+
+    SGR_CACHE = Hash.new { |h, d| h[d] = {} }
+
+    def sgr_for(key, fg, bg, bold, depth)
+      cache = SGR_CACHE[depth]
+      cache.clear if cache.size > 50_000
+      cache[key] ||= (depth == :none && !bold && bg.nil? ? "\e[0m" : Color.sgr(fg, bg, bold, depth)).freeze
+    end
   end
 end

data/lib/dopairb/cli.rb

@@ -15,13 +15,13 @@ module Dopairb
         o.separator ""
         o.separator "IRB with fireworks. Every other option is handed to IRB."
         o.separator ""
-        o.on("--intensity=LEVEL", Config::INTENSITIES.map(&:to_s), "off / low / normal (default) / max") { |v| settings << [:intensity, v] }
+        o.on("--intensity=LEVEL", Config::INTENSITIES.map(&:to_s), "off / low / normal / max (default)") { |v| settings << [:intensity, v] }
         o.on("--calm", "low intensity, no flash, shorter effects") { settings.concat([[:intensity, :low], [:flash, :off], [:duration, 0.7]]) }
-        o.on("--max", "everything at maximum") { settings << [:intensity, :max] }
-        o.on("--party", "max + full-screen flash + bell") { settings.concat([[:intensity, :max], [:flash, :full], [:sound, true]]) }
+        o.on("--max", "everything at maximum (the default)") { settings << [:intensity, :max] }
+        o.on("--party", "max + full-screen flash + sound effects") { settings.concat([[:intensity, :max], [:flash, :full], [:sound, :sfx]]) }
         o.on("--[no-]flash[=MODE]", "flash: off / soft (default) / full") { |v| settings << [:flash, v.nil? ? :soft : (v == false ? :off : v)] }
         o.on("--[no-]motion", "animations (default on)") { |v| settings << [:motion, v] }
-        o.on("--[no-]sound", "terminal bell on big moments (default off)") { |v| settings << [:sound, v] }
+        o.on("--[no-]sound[=MODE]", "sound: off / bell / sfx (default)") { |v| settings << [:sound, v.nil? ? :sfx : (v == false ? :off : v)] }
         o.on("--[no-]hud", "COMBO / SCORE next to the prompt (default on)") { |v| settings << [:hud, v] }
         o.on("--[no-]keys", "per-keystroke effects (default on)") { |v| settings << [:keys, v] }
         o.on("--[no-]intro", "title animation (default on)") { |v| settings << [:intro, v] }
@@ -61,9 +61,7 @@ module Dopairb
       ours, irb_args = split_args(argv.dup)
       settings = []
       parser(settings).parse!(ours)
-      settings.each do |k, v|
-        k == :string ? Dopairb.config.apply_string(v) : Dopairb.config.set(k, v)
-      end
+      settings.each { |k, v| Dopairb.override(k, v) }
       run_irb(irb_args)
     rescue OptionParser::ParseError, ArgumentError => e
       warn "dopairb: #{e.message}"

data/lib/dopairb/config.rb

@@ -7,12 +7,13 @@ module Dopairb
     FLASHES = %i[off soft full].freeze
     COLORS = %i[auto truecolor 256 16 none].freeze
     TRAILS = %i[none big all].freeze
+    SOUNDS = %i[off bell sfx].freeze
 
     DESCRIPTIONS = {
       intensity: "off / low / normal / max  -- overall amount of effects",
       motion: "on / off  -- animations (off = static badges only)",
       flash: "off / soft / full  -- soft = region only, full = whole screen",
-      sound: "on / off  -- terminal bell on big moments",
+      sound: "off / bell / sfx  -- sfx = synthesized effects (paplay/aplay/afplay/WSL), bell = terminal bell",
       hud: "on / off  -- COMBO / SCORE / CHARGE next to the prompt",
       duration: "float multiplier for every effect length (e.g. 0.5, 2)",
       color: "auto / truecolor / 256 / 16 / none",
@@ -20,15 +21,16 @@ module Dopairb
       charge: "seconds (max 0.3) of wind-up before a fast result lands; 0 disables",
       intro: "on / off  -- title animation at startup",
       keys: "on / off  -- per-keystroke effects while typing",
+      binding_irb: "on / off  -- effects in sessions opened by binding.irb too",
     }.freeze
 
-    attr_reader :intensity, :motion, :flash, :sound, :hud, :duration, :color, :trail, :charge, :intro, :keys
+    attr_reader :intensity, :motion, :flash, :sound, :hud, :duration, :color, :trail, :charge, :intro, :keys, :binding_irb
 
     def initialize
-      @intensity = :normal
+      @intensity = :max
       @motion = true
       @flash = :soft
-      @sound = false
+      @sound = :sfx
       @hud = true
       @duration = 1.0
       @color = :auto
@@ -36,6 +38,7 @@ module Dopairb
       @charge = 0.12
       @intro = true
       @keys = true
+      @binding_irb = true
     end
 
     def level
@@ -56,7 +59,10 @@ module Dopairb
         v = bool_or_nil(value)
         @color = v.nil? ? enum(value, COLORS, name) : (v ? :auto : :none)
       when :trail then @trail = enum(value, TRAILS, name)
-      when :motion, :sound, :hud, :intro, :keys
+      when :sound
+        v = bool_or_nil(value)
+        @sound = v.nil? ? enum(value, SOUNDS, name) : (v ? :sfx : :off)
+      when :motion, :hud, :intro, :keys, :binding_irb
         v = bool_or_nil(value)
         raise ArgumentError, "#{name} expects on/off, got #{value.inspect}" if v.nil?
         instance_variable_set(:"@#{name}", v)

data/lib/dopairb/demo.rb

@@ -7,8 +7,9 @@ module Dopairb
 
     module_function
 
-    def ev(kind, info, flags: [], gain: 120, combo: 3, streak: 0)
-      E.new(kind: kind, tier: nil, info: info, flags: flags, gain: gain, combo: combo, streak: streak, score: 12_480)
+    def ev(kind, info, flags: [], gain: 120, combo: 3, streak: 0, mult: 1, level: 5)
+      E.new(kind: kind, tier: nil, info: info, flags: flags, gain: gain, combo: combo, streak: streak, score: 12_480,
+            mult: mult, level: level)
     end
 
     def cases
@@ -33,9 +34,24 @@ module Dopairb
         ["1 + 1", ev(:success, { type: :integer, value: 2 }, flags: [:comeback], combo: 1, streak: 5, gain: 600)],
         ["loop {}", ev(:interrupt, { charge: 60 })],
         ["2**128", ev(:success, { type: :integer, value: 2**128 }, flags: [:new_record, :record_jump], gain: 420)],
+        ["[3, 1, 2].sort", ev(:success, { type: :array, size: 3 }, flags: [:critical], gain: 960, mult: 8)],
+        ["12.fdiv(5)", ev(:success, { type: :float, value: 2.4 }, flags: [:fever], combo: 12, gain: 1100, mult: 2)],
+        ["21.0 * 2", ev(:success, { type: :float, value: 42.0 }, flags: [:fever, :combo_best], combo: 13, gain: 1200, mult: 2)],
+        ["rand(777)", ev(:success, { type: :integer, value: 777 }, flags: [:jackpot], gain: 6_400, mult: 16)],
+        ["'level' * 2", ev(:success, { type: :string, length: 10, head: "levellevel", art: :great_wave, art_new: true, gallery: [1, 5] },
+                           flags: [:level_up], gain: 200, level: 6)],
       ]
     end
 
+    # Let the sound ring out so the next one does not step on it.
+    def wait_for_sound(config, scene, t0)
+      return unless config.sound == :sfx && scene&.sfx && Sound.available?
+      ends = (scene.pre + scene.impact_at) * config.duration + Sound.tail(scene.sfx)
+      wait = ends - (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0)
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + wait
+      sleep 0.02 while Process.clock_gettime(Process::CLOCK_MONOTONIC) < deadline && !Term.input_pending?
+    end
+
     def run(mod)
       d = mod.session&.director || Director.new(mod.config)
       unless mod.active?
@@ -51,9 +67,11 @@ module Dopairb
         if event.kind == :failure && event.info[:type] == :syntax
           event.info[:column] = [code.size, event.info[:column]].min
         end
-        d.play_event(event, input: shot, pre: event.kind == :success ? mod.config.charge : 0)
+        t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        scene = d.play_event(event, input: shot, pre: event.kind == :success ? mod.config.charge : 0)
         Term.write("\e[2m=> (demo)\e[0m\r\n")
-        sleep 0.15
+        wait_for_sound(mod.config, scene, t0)
+        sleep 0.4
       end
       Term.write("\e[0m")
     end

data/lib/dopairb/director.rb

@@ -6,7 +6,7 @@ module Dopairb
   class Director
     FPS = 40.0
 
-    attr_reader :config
+    attr_reader :config, :rng
 
     def initialize(config, rng: Random.new)
       @config = config
@@ -50,20 +50,35 @@ module Dopairb
           Scenes::Banner.new(ctx, event, text: text, palette: palette, mega: true, rainbow: rainbow, sub: sub)
         end
       end
-      if event.flag?(:comeback)
+      full = lambda { self.ctx(rows: ctx.rows, cols: ctx.w + 1).tap { |c| c.depth = ctx.depth } }
+      if event.flag?(:jackpot)
+        Scenes::Jackpot.new(ctx, event)
+      elsif event.flag?(:level_up) || (event.flag?(:art_drop) && info[:art])
+        if @config.motion && @config.level >= 2 && info[:art] && Scenes::Masterpiece.fits?(ctx.rows, ctx.w + 1)
+          Scenes::Masterpiece.new(full.(), event)
+        elsif event.flag?(:level_up)
+          mega.("LEVEL UP!", Color::NEON, rainbow: true, sub: "LV #{event.level}")
+        else
+          Scenes::Banner.new(ctx, event, text: "ART DROP!", palette: Color::GOLD, sub: Gallery.find(info[:art])&.title)
+        end
+      elsif event.flag?(:comeback)
         mega.(event.streak >= 2 ? "COMEBACK!" : "FIXED!", Color::GOLD, rainbow: event.streak >= 2)
       elsif event.flag?(:eval_milestone)
         mega.("#{Fx.number_with_commas(event_evals(event))} EVALS", Color::NEON, rainbow: true)
       elsif event.flag?(:record_jump)
         mega.("NEW RECORD", Color::GOLD, rainbow: true, sub: number_text(info))
       elsif event.flag?(:combo_mega)
-        mega.("COMBO #{event.combo}!", Color::FIRE, rainbow: event.combo >= 50)
+        mega.("COMBO #{event.combo}!", Color::FIRE, rainbow: event.combo >= 50, sub: event.flag?(:fever_start) ? "FEVER TIME! ALL POINTS x2" : nil)
+      elsif event.flag?(:combo_best)
+        Scenes::Banner.new(ctx, event, text: "BEST COMBO!", palette: Color::FIRE, sub: "ALL-TIME BEST #{event.combo}")
       elsif info[:type] == :definition
         Scenes::Unlock.new(ctx, event)
       elsif event.flag?(:combo_milestone) && event.combo >= 5
         Scenes::Banner.new(ctx, event, text: "COMBO #{event.combo}", palette: Color::FIRE)
       elsif event.flag?(:first_hit)
         Scenes::Banner.new(ctx, event, text: "FIRST HIT!", palette: Color::ICE)
+      elsif event.flag?(:critical) && !counter?(event)
+        Scenes::Critical.new(ctx, event)
       elsif event.flag?(:output_rain)
         Scenes::Rain.new(ctx, event)
       else
@@ -71,6 +86,11 @@ module Dopairb
       end
     end
 
+    def counter?(event)
+      v = event.info[:value]
+      %i[integer float].include?(event.info[:type]) && (v.abs >= 10_000 || event.flag?(:new_record))
+    end
+
     def value_scene(event, ctx)
       info = event.info
       case info[:type]
@@ -90,32 +110,76 @@ module Dopairb
       return if @config.off?
       c = ctx(input: input, pre: pre)
       c.input = nil if input && input.size + 12 > c.rows
-      play(scene_for(event, c))
+      scene = scene_for(event, c)
+      play(scene)
+      encore(event, c) if Scenes::Jackpot === scene
+      scene
+    end
+
+    # A jackpot pays out a masterpiece too: too good to fold away.
+    def encore(event, c)
+      return unless event.info[:art] && @config.motion && @config.level >= 2
+      return if Term.input_pending? || !Scenes::Masterpiece.fits?(c.rows, c.w + 1)
+      full = ctx(rows: c.rows, cols: c.w + 1).tap { |x| x.depth = c.depth }
+      play(Scenes::Masterpiece.new(full, event))
+    end
+
+    # Cute loading screen until ready.call is true (e.g. the intro sound exists).
+    def loading(&ready)
+      return if @config.off?
+      scene = Scenes::Loading.new(ctx, ready)
+      return unless @config.motion && fits?(scene)
+      run(scene)
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      raise if SystemExit === e || (SignalException === e && !(Interrupt === e))
     end
 
-    def intro
+    def intro(career = nil)
       return if @config.off? || !@config.intro
-      play(Scenes::Intro.new(ctx), force_trail: true)
+      play(Scenes::Intro.new(ctx, career), force_trail: true)
     end
 
     def outro(stats)
       return if @config.off?
-      play(Scenes::Outro.new(ctx, stats), force_trail: true)
+      c = ctx
+      scene = if @config.motion && Scenes::Finale.fits?(c.rows, c.w + 1) && @config.level >= 2
+                Scenes::Finale.new(c, stats)
+              else
+                Scenes::Outro.new(c, stats)
+              end
+      # render the synced track now so it does not start late
+      Sound.file(scene.sfx, @config.duration) if @config.sound == :sfx && scene.sfx && Sound.available?
+      play(scene, force_trail: true)
     end
 
     def play(scene, force_trail: false)
       animated = @config.motion && scene.ctx.w >= 20 && fits?(scene)
       animated = false if animated && Term.input_pending?
+      sound(scene, animated) unless !animated && @config.motion
       run(scene) if animated
-      Term.bell if @config.sound && scene.bell? && animated
       emit_trail(scene, force_trail)
     rescue Exception => e # rubocop:disable Lint/RescueException
       raise if SystemExit === e || (SignalException === e && !(Interrupt === e))
       # Never let an effect break the REPL; Ctrl-C during an effect just skips it.
+      Dopairb.debug(e) unless Interrupt === e
     end
 
     private
 
+    def sound(scene, animated)
+      case @config.sound
+      when :bell
+        Term.bell if scene.bell?
+      when :sfx
+        if Sound.available?
+          delay = animated ? (scene.pre + scene.impact_at) * @config.duration : 0.0
+          Sound.play(scene.sfx, delay: delay, stretch: @config.duration) if scene.sfx
+        elsif scene.bell?
+          Term.bell
+        end
+      end
+    end
+
     def event_evals(_event)
       Dopairb.session&.game&.evals.to_i
     end
@@ -126,8 +190,7 @@ module Dopairb
 
     def fits?(scene)
       top = scene.top? ? scene.ctx.input.size : 0
-      alt = scene.is_a?(Scenes::Banner) && scene.height == scene.ctx.rows
-      alt || scene.height + top <= scene.ctx.rows - 1
+      scene.alt? || scene.height + top <= scene.ctx.rows - 1
     end
 
     def emit_trail(scene, force)
@@ -140,7 +203,7 @@ module Dopairb
     end
 
     def run(scene)
-      alt = scene.is_a?(Scenes::Banner) && scene.height == scene.ctx.rows && scene.mega?
+      alt = scene.alt?
       top = !alt && scene.top? ? scene.ctx.input.rows : []
       stage = alt ? AltStage.new(scene.height) : Stage.new(scene.height, top: top)
       depth = scene.depth
@@ -153,7 +216,7 @@ module Dopairb
           loop do
             break if Term.input_pending? || !stage.open?
             t = (now - t0) / @config.duration
-            break if t >= scene.total_length
+            break if t >= scene.total_length || scene.done?(t)
             lines = []
             unless top.empty?
               tc = Canvas.new(scene.ctx.w, top.size)

data/lib/dopairb/fx.rb

@@ -111,6 +111,29 @@ module Dopairb
       width * scale
     end
 
+    # The big font squeezed into three rows with half blocks (▀ ▄ █).
+    # Returns the width drawn, or nil when the terminal lacks the glyphs.
+    def half_text(canvas, text, x, y, color_fn)
+      up = Term.glyph("▀", nil)
+      down = Term.glyph("▄", nil)
+      full = Term.glyph("█", nil)
+      return nil unless up && down && full
+      bm = Font.bitmap(text)
+      width = bm[0].size
+      3.times do |r|
+        top = bm[r * 2]
+        bot = bm[r * 2 + 1] || []
+        width.times do |cx|
+          a = top[cx]
+          b = bot[cx]
+          next unless a || b
+          ch = a && b ? full : (a ? up : down)
+          canvas.put(x + cx, y + r, ch, color_fn.(cx, r, cx.fdiv([width - 1, 1].max)))
+        end
+      end
+      width
+    end
+
     def text_fits?(text, w, scale = 1)
       Font.width(text, scale: scale) <= w
     end