dopairb 0.1.0

data/lib/dopairb/color.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Dopairb
+  # RGB helpers and SGR encoding for truecolor / 256 / 16 / no-color terminals.
+  module Color
+    FIRE  = [[255, 255, 230], [255, 236, 110], [255, 160, 20], [235, 60, 10], [120, 10, 30], [40, 0, 20]].freeze
+    ICE   = [[240, 255, 255], [130, 230, 255], [40, 140, 255], [30, 50, 190], [20, 10, 80]].freeze
+    GOLD  = [[255, 255, 240], [255, 230, 120], [255, 190, 40], [200, 120, 0], [90, 40, 0]].freeze
+    TOXIC = [[240, 255, 230], [150, 255, 120], [40, 220, 90], [0, 130, 70], [0, 50, 30]].freeze
+    BLOOD = [[255, 230, 230], [255, 90, 90], [220, 20, 40], [130, 0, 20], [50, 0, 10]].freeze
+    NEON  = [[255, 240, 255], [255, 110, 230], [190, 60, 255], [80, 40, 220], [30, 10, 90]].freeze
+    SMOKE = [[235, 235, 235], [170, 170, 180], [110, 110, 125], [60, 60, 70], [30, 30, 35]].freeze
+    STEEL = [[230, 240, 255], [150, 170, 200], [90, 105, 140], [50, 60, 85], [25, 28, 40]].freeze
+
+    BASIC16 = [
+      [0, 0, 0], [205, 0, 0], [0, 205, 0], [205, 205, 0], [0, 0, 238], [205, 0, 205], [0, 205, 205], [229, 229, 229],
+      [127, 127, 127], [255, 0, 0], [0, 255, 0], [255, 255, 0], [92, 92, 255], [255, 0, 255], [0, 255, 255], [255, 255, 255],
+    ].freeze
+
+    module_function
+
+    def clamp(x)
+      x = x.to_i
+      x < 0 ? 0 : (x > 255 ? 255 : x)
+    end
+
+    def mix(a, b, t)
+      t = t < 0 ? 0.0 : (t > 1 ? 1.0 : t)
+      [clamp(a[0] + (b[0] - a[0]) * t), clamp(a[1] + (b[1] - a[1]) * t), clamp(a[2] + (b[2] - a[2]) * t)]
+    end
+
+    def scale(c, k)
+      [clamp(c[0] * k), clamp(c[1] * k), clamp(c[2] * k)]
+    end
+
+    def hsv(h, s = 1.0, v = 1.0)
+      h = (h % 360) / 60.0
+      i = h.floor
+      f = h - i
+      p = v * (1 - s)
+      q = v * (1 - s * f)
+      t = v * (1 - s * (1 - f))
+      r, g, b = [[v, t, p], [q, v, p], [p, v, t], [p, q, v], [t, p, v], [v, p, q]][i % 6]
+      [clamp(r * 255), clamp(g * 255), clamp(b * 255)]
+    end
+
+    def rainbow(t, s = 0.85, v = 1.0)
+      hsv(t * 360, s, v)
+    end
+
+    # t in 0..1 walks through the stops
+    def ramp(stops, t)
+      t = t < 0 ? 0.0 : (t > 1 ? 1.0 : t)
+      pos = t * (stops.size - 1)
+      i = pos.floor
+      return stops[-1] if i >= stops.size - 1
+      mix(stops[i], stops[i + 1], pos - i)
+    end
+
+    def sgr(fg, bg, bold, depth)
+      codes = ["0"]
+      codes << "1" if bold
+      if depth == :none
+        codes << "7" if bg && luminance(bg) > 90
+      else
+        codes << fg_code(fg, depth) if fg
+        codes << bg_code(bg, depth) if bg
+      end
+      "\e[#{codes.join(';')}m"
+    end
+
+    def fg(c, depth, bold: false)
+      sgr(c, nil, bold, depth)
+    end
+
+    def reset = "\e[0m"
+
+    def fg_code(c, depth)
+      case depth
+      when :truecolor then "38;2;#{c[0]};#{c[1]};#{c[2]}"
+      when :"256" then "38;5;#{to256(c)}"
+      else
+        i = to16(c)
+        (i < 8 ? 30 + i : 82 + i).to_s
+      end
+    end
+
+    def bg_code(c, depth)
+      case depth
+      when :truecolor then "48;2;#{c[0]};#{c[1]};#{c[2]}"
+      when :"256" then "48;5;#{to256(c)}"
+      else
+        i = to16(c)
+        (i < 8 ? 40 + i : 92 + i).to_s
+      end
+    end
+
+    def luminance(c)
+      0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2]
+    end
+
+    def to256(c)
+      r, g, b = c
+      if (r - g).abs < 10 && (g - b).abs < 10
+        return 16 if r < 8
+        return 231 if r > 246
+        return 232 + ((r - 8) / 10.0).round.clamp(0, 23)
+      end
+      q = ->(v) { v < 48 ? 0 : (v < 115 ? 1 : ((v - 35) / 40).clamp(0, 5)) }
+      16 + 36 * q.(r) + 6 * q.(g) + q.(b)
+    end
+
+    def to16(c)
+      best = 0
+      bd = Float::INFINITY
+      BASIC16.each_with_index do |bc, i|
+        d = (bc[0] - c[0])**2 * 2 + (bc[1] - c[1])**2 * 4 + (bc[2] - c[2])**2 * 3
+        if d < bd
+          bd = d
+          best = i
+        end
+      end
+      best
+    end
+  end
+end

data/lib/dopairb/config.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Dopairb
+  # User-tunable knobs. See `dopa help` or README for the meaning of each.
+  class Config
+    INTENSITIES = %i[off low normal max].freeze
+    FLASHES = %i[off soft full].freeze
+    COLORS = %i[auto truecolor 256 16 none].freeze
+    TRAILS = %i[none big all].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",
+      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",
+      trail: "none / big / all  -- which effects leave a one-line badge",
+      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",
+    }.freeze
+
+    attr_reader :intensity, :motion, :flash, :sound, :hud, :duration, :color, :trail, :charge, :intro, :keys
+
+    def initialize
+      @intensity = :normal
+      @motion = true
+      @flash = :soft
+      @sound = false
+      @hud = true
+      @duration = 1.0
+      @color = :auto
+      @trail = :big
+      @charge = 0.12
+      @intro = true
+      @keys = true
+    end
+
+    def level
+      INTENSITIES.index(@intensity)
+    end
+
+    def off? = @intensity == :off
+    def max? = @intensity == :max
+
+    def set(name, value)
+      name = name.to_s.strip.downcase.tr("-", "_").to_sym
+      case name
+      when :intensity then @intensity = enum(value, INTENSITIES, name)
+      when :flash
+        v = bool_or_nil(value)
+        @flash = v.nil? ? enum(value, FLASHES, name) : (v ? :soft : :off)
+      when :color
+        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
+        v = bool_or_nil(value)
+        raise ArgumentError, "#{name} expects on/off, got #{value.inspect}" if v.nil?
+        instance_variable_set(:"@#{name}", v)
+      when :duration
+        f = Float(value.to_s)
+        raise ArgumentError, "duration must be in 0.1..5" unless (0.1..5).cover?(f)
+        @duration = f
+      when :charge
+        f = Float(value.to_s)
+        raise ArgumentError, "charge must be in 0..0.3 (seconds)" unless (0..0.3).cover?(f)
+        @charge = f
+      else
+        raise ArgumentError, "unknown setting #{name.inspect} (known: #{DESCRIPTIONS.keys.join(', ')})"
+      end
+      self
+    end
+
+    # "intensity=max,flash=off" (DOPAIRB env var / --set option)
+    def apply_string(str)
+      str.to_s.split(/[,\s]+/).reject(&:empty?).each do |pair|
+        k, v = pair.split("=", 2)
+        raise ArgumentError, "expected key=value, got #{pair.inspect}" unless v
+        set(k, v)
+      end
+      self
+    end
+
+    def to_h
+      DESCRIPTIONS.keys.to_h { |k| [k, public_send(k)] }
+    end
+
+    def describe
+      to_h.map { |k, v| format("  %-10s %-8s %s", k, show(v), DESCRIPTIONS[k]) }.join("\n")
+    end
+
+    private
+
+    def show(v)
+      case v
+      when true then "on"
+      when false then "off"
+      else v.to_s
+      end
+    end
+
+    def enum(value, list, name)
+      sym = value.to_s.strip.downcase.to_sym
+      return sym if list.include?(sym)
+      raise ArgumentError, "#{name} must be one of #{list.join(' / ')}, got #{value.inspect}"
+    end
+
+    def bool_or_nil(value)
+      case value.to_s.strip.downcase
+      when "on", "true", "yes", "1" then true
+      when "off", "false", "no", "0" then false
+      end
+    end
+  end
+end

data/lib/dopairb/demo.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Dopairb
+  # `dopa demo`: every scene once, with made-up events. Does not touch the score.
+  module Demo
+    E = Game::Event
+
+    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)
+    end
+
+    def cases
+      [
+        ["(1..100).sum", ev(:success, { type: :integer, value: 5050 })],
+        ["[].first", ev(:success, { type: :nil })],
+        ["1 < 2", ev(:success, { type: :true })],
+        ["[] .any?", ev(:success, { type: :false })],
+        ["2**64", ev(:success, { type: :integer, value: 2**64 })],
+        ["'dopamine ' * 12", ev(:success, { type: :string, length: 108, head: "dopamine " * 12 })],
+        ["(1..24).to_a", ev(:success, { type: :array, size: 24 })],
+        ["def boost = :on", ev(:definition, { type: :definition, what: :method, name: "boost" })],
+        ["3.times { puts }", ev(:success, { type: :nil, out_lines: 120 }, flags: [:output_rain])],
+        ["x = 1", ev(:success, { type: :integer, value: 1 }, flags: [:first_hit], combo: 1)],
+        ["10.times.sum", ev(:success, { type: :integer, value: 45 }, flags: [:combo_milestone, :combo_mega], combo: 10, gain: 1350)],
+        ["1 + ", ev(:failure, { type: :syntax, class_name: "SyntaxError", line: 1, column: 4, detail: "unexpected end-of-input; expected an expression after the operator" })],
+        ["undefined_thing", ev(:failure, { type: :name, class_name: "NameError", name: "undefined_thing", message: "undefined local variable or method 'undefined_thing' for main" }, combo: 0, streak: 1)],
+        ["1.shout", ev(:failure, { type: :nomethod, class_name: "NoMethodError", name: "shout", receiver: "Integer", message: "undefined method 'shout' for an instance of Integer" }, combo: 0, streak: 2)],
+        ["1 + '1'", ev(:failure, { type: :type, class_name: "TypeError", sides: %w[String Integer], message: "String can't be coerced into Integer" }, combo: 0, streak: 3)],
+        ["[1].first(1, 2)", ev(:failure, { type: :argument, class_name: "ArgumentError", sides: ["given 2", "expected 0..1"], message: "wrong number of arguments (given 2, expected 0..1)" }, combo: 0, streak: 4)],
+        ["raise 'boom'", ev(:failure, { type: :other, class_name: "RuntimeError", message: "boom" }, combo: 0, streak: 5)],
+        ["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)],
+      ]
+    end
+
+    def run(mod)
+      d = mod.session&.director || Director.new(mod.config)
+      unless mod.active?
+        puts "dopairb: not active (no terminal or intensity=off)"
+        return
+      end
+      prompt = "\e[1;35mdopa\e[0m> "
+      cases.each do |code, event|
+        break if Term.input_pending?
+        line = "#{prompt}#{IRB::Color.colorize_code(code, complete: true)}"
+        Term.write("#{line}\r\n")
+        shot = InputShot.new(rows: [line], lines: [[6, code]], code: code, screen_width: Term.cols)
+        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)
+        Term.write("\e[2m=> (demo)\e[0m\r\n")
+        sleep 0.15
+      end
+      Term.write("\e[0m")
+    end
+  end
+end

data/lib/dopairb/director.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module Dopairb
+  # Picks a scene for each event and plays it. Bigger moments win; smaller
+  # ones are folded into the subtitle instead of being queued.
+  class Director
+    FPS = 40.0
+
+    attr_reader :config
+
+    def initialize(config, rng: Random.new)
+      @config = config
+      @rng = rng
+      @last_flash = -10.0
+    end
+
+    def ctx(input: nil, pre: 0.0, rows: nil, cols: nil)
+      r, c = Term.size
+      Ctx.new(w: (cols || c) - 1, rows: rows || r, depth: Term.depth(@config), config: @config, rng: @rng,
+              input: input, pre: pre, compact: @config.level <= 1 || (cols || c) < 40)
+    end
+
+    def scene_for(event, ctx)
+      info = event.info
+      case event.kind
+      when :interrupt then Scenes::Scatter.new(ctx, event)
+      when :failure then failure_scene(info[:type], ctx, event)
+      else success_scene(event, ctx)
+      end
+    end
+
+    def failure_scene(type, ctx, event)
+      case type
+      when :syntax then Scenes::Crack.new(ctx, event)
+      when :name then Scenes::Spotlight.new(ctx, event)
+      when :nomethod then Scenes::Snap.new(ctx, event)
+      when :type, :argument then Scenes::Clash.new(ctx, event)
+      else Scenes::FailureScene.new(ctx, event)
+      end
+    end
+
+    def success_scene(event, ctx)
+      info = event.info
+      alt = @config.max? && @config.motion
+      mega = lambda do |text, palette, rainbow: false, sub: nil|
+        if alt
+          Scenes::Banner.new(self.ctx(rows: ctx.rows, cols: ctx.w + 1).tap { |c| c.depth = ctx.depth }, event, text: text, palette: palette, mega: true,
+                                                                    rainbow: rainbow, sub: sub, alt: true)
+        else
+          Scenes::Banner.new(ctx, event, text: text, palette: palette, mega: true, rainbow: rainbow, sub: sub)
+        end
+      end
+      if 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)
+      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?(:output_rain)
+        Scenes::Rain.new(ctx, event)
+      else
+        value_scene(event, ctx)
+      end
+    end
+
+    def value_scene(event, ctx)
+      info = event.info
+      case info[:type]
+      when :nil then Scenes::Puff.new(ctx, event)
+      when :true, :false then Scenes::Stamp.new(ctx, event)
+      when :integer, :float
+        info[:value].abs >= 10_000 || event.flag?(:new_record) ? Scenes::Counter.new(ctx, event) : Scenes::Hit.new(ctx, event)
+      when :huge
+        Scenes::Banner.new(ctx, event, text: "HUGE", palette: Color::GOLD, sub: "#{Fx.number_with_commas(info[:digits])} DIGITS")
+      when :string then info[:length] >= 40 ? Scenes::Stream.new(ctx, event) : Scenes::Hit.new(ctx, event)
+      when :array, :hash then info[:size] > 0 ? Scenes::Crate.new(ctx, event) : Scenes::Hit.new(ctx, event)
+      else Scenes::Hit.new(ctx, event)
+      end
+    end
+
+    def play_event(event, input: nil, pre: 0.0)
+      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))
+    end
+
+    def intro
+      return if @config.off? || !@config.intro
+      play(Scenes::Intro.new(ctx), force_trail: true)
+    end
+
+    def outro(stats)
+      return if @config.off?
+      play(Scenes::Outro.new(ctx, stats), 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?
+      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.
+    end
+
+    private
+
+    def event_evals(_event)
+      Dopairb.session&.game&.evals.to_i
+    end
+
+    def number_text(info)
+      Integer === info[:value] ? Fx.number_with_commas(info[:value]) : info[:value].to_s
+    end
+
+    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
+    end
+
+    def emit_trail(scene, force)
+      tr = scene.trail
+      return unless tr
+      ok = force || @config.trail == :all || (@config.trail == :big && scene.big?)
+      return unless ok
+      tr = tr.gsub(/\e\[[\d;]*m/, "") if scene.depth == :none
+      Term.write(tr.gsub("\n", "\r\n") + "\e[0m\r\n")
+    end
+
+    def run(scene)
+      alt = scene.is_a?(Scenes::Banner) && scene.height == scene.ctx.rows && scene.mega?
+      top = !alt && scene.top? ? scene.ctx.input.rows : []
+      stage = alt ? AltStage.new(scene.height) : Stage.new(scene.height, top: top)
+      depth = scene.depth
+      flash_off = nil
+      Term.raw do
+        stage.open
+        t0 = now
+        flashed = false
+        begin
+          loop do
+            break if Term.input_pending? || !stage.open?
+            t = (now - t0) / @config.duration
+            break if t >= scene.total_length
+            lines = []
+            unless top.empty?
+              tc = Canvas.new(scene.ctx.w, top.size)
+              lines.concat(scene.draw_top(tc, t) ? tc.render(depth) : top)
+            end
+            ts = t - scene.pre
+            c = Canvas.new(scene.ctx.w, scene.height)
+            scene.draw(c, ts) if ts >= 0
+            lines.concat(c.render(depth, shake: ts >= 0 ? scene.shake(ts) : 0))
+            if !flashed && scene.flash_at && ts >= scene.flash_at
+              flashed = true
+              if @config.flash == :full && now - @last_flash > 0.4
+                @last_flash = now
+                Term.write("\e[?5h")
+                flash_off = now + 0.05
+              end
+            end
+            stage.draw(lines)
+            if flash_off && now >= flash_off
+              Term.write("\e[?5l")
+              flash_off = nil
+            end
+            sleep(1 / FPS)
+          end
+        ensure
+          Term.write("\e[?5l") if flash_off
+          stage.close
+        end
+      end
+    end
+
+    def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+end

data/lib/dopairb/font.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Dopairb
+  # 5-row bitmap font for the big banners.
+  module Font
+    HEIGHT = 5
+
+    RAW = {
+      "A" => [" ### ", "#   #", "#####", "#   #", "#   #"],
+      "B" => ["#### ", "#   #", "#### ", "#   #", "#### "],
+      "C" => [" ####", "#    ", "#    ", "#    ", " ####"],
+      "D" => ["#### ", "#   #", "#   #", "#   #", "#### "],
+      "E" => ["#####", "#    ", "#### ", "#    ", "#####"],
+      "F" => ["#####", "#    ", "#### ", "#    ", "#    "],
+      "G" => [" ####", "#    ", "#  ##", "#   #", " ####"],
+      "H" => ["#   #", "#   #", "#####", "#   #", "#   #"],
+      "I" => ["###", " # ", " # ", " # ", "###"],
+      "J" => ["  ###", "   # ", "   # ", "#  # ", " ##  "],
+      "K" => ["#   #", "#  # ", "###  ", "#  # ", "#   #"],
+      "L" => ["#    ", "#    ", "#    ", "#    ", "#####"],
+      "M" => ["#   #", "## ##", "# # #", "#   #", "#   #"],
+      "N" => ["#   #", "##  #", "# # #", "#  ##", "#   #"],
+      "O" => [" ### ", "#   #", "#   #", "#   #", " ### "],
+      "P" => ["#### ", "#   #", "#### ", "#    ", "#    "],
+      "Q" => [" ### ", "#   #", "# # #", "#  # ", " ## #"],
+      "R" => ["#### ", "#   #", "#### ", "#  # ", "#   #"],
+      "S" => [" ####", "#    ", " ### ", "    #", "#### "],
+      "T" => ["#####", "  #  ", "  #  ", "  #  ", "  #  "],
+      "U" => ["#   #", "#   #", "#   #", "#   #", " ### "],
+      "V" => ["#   #", "#   #", "#   #", " # # ", "  #  "],
+      "W" => ["#   #", "#   #", "# # #", "## ##", "#   #"],
+      "X" => ["#   #", " # # ", "  #  ", " # # ", "#   #"],
+      "Y" => ["#   #", " # # ", "  #  ", "  #  ", "  #  "],
+      "Z" => ["#####", "   # ", "  #  ", " #   ", "#####"],
+      "0" => [" ### ", "#  ##", "# # #", "##  #", " ### "],
+      "1" => [" # ", "## ", " # ", " # ", "###"],
+      "2" => ["#### ", "    #", " ### ", "#    ", "#####"],
+      "3" => ["#### ", "    #", " ### ", "    #", "#### "],
+      "4" => ["#   #", "#   #", "#####", "    #", "    #"],
+      "5" => ["#####", "#    ", "#### ", "    #", "#### "],
+      "6" => [" ### ", "#    ", "#### ", "#   #", " ### "],
+      "7" => ["#####", "    #", "   # ", "  #  ", "  #  "],
+      "8" => [" ### ", "#   #", " ### ", "#   #", " ### "],
+      "9" => [" ### ", "#   #", " ####", "    #", " ### "],
+      "!" => ["#", "#", "#", " ", "#"],
+      "?" => ["### ", "   #", " ## ", "    ", " #  "],
+      "." => [" ", " ", " ", " ", "#"],
+      "," => ["  ", "  ", "  ", " #", "# "],
+      ":" => [" ", "#", " ", "#", " "],
+      "'" => ["#", "#", " ", " ", " "],
+      "+" => ["     ", "  #  ", "#####", "  #  ", "     "],
+      "-" => ["    ", "    ", "####", "    ", "    "],
+      "=" => ["    ", "####", "    ", "####", "    "],
+      "x" => ["   ", "# #", " # ", "# #", "   "],
+      "/" => ["    #", "   # ", "  #  ", " #   ", "#    "],
+      ">" => ["#   ", " #  ", "  # ", " #  ", "#   "],
+      "<" => ["   #", "  # ", " #  ", "  # ", "   #"],
+      "^" => [" # ", "# #", "   ", "   ", "   "],
+      "#" => [" # # ", "#####", " # # ", "#####", " # # "],
+      "%" => ["#   #", "   # ", "  #  ", " #   ", "#   #"],
+      "*" => ["     ", "# # #", " ### ", "# # #", "     "],
+      " " => [" ", " ", " ", " ", " "],
+    }.freeze
+
+    GLYPHS = RAW.transform_values { |rows| rows.map { |r| r.chars.map { |c| c == "#" } }.freeze }.freeze
+
+    module_function
+
+    def glyph(ch)
+      GLYPHS[ch] || GLYPHS[ch.upcase] || GLYPHS["?"]
+    end
+
+    # => array of HEIGHT rows, each an array of booleans
+    def bitmap(text, spacing: 1)
+      rows = Array.new(HEIGHT) { [] }
+      text.each_char.with_index do |ch, i|
+        g = glyph(ch)
+        HEIGHT.times do |y|
+          rows[y].concat([false] * spacing) if i > 0
+          rows[y].concat(g[y])
+        end
+      end
+      rows
+    end
+
+    def width(text, scale: 1, spacing: 1)
+      return 0 if text.empty?
+      (text.each_char.sum { |c| glyph(c)[0].size } + spacing * (text.size - 1)) * scale
+    end
+  end
+end