dopairb 0.1.0

data/lib/dopairb/fx.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module Dopairb
+  # Drawing primitives shared by scenes and the input lane. All motion is a
+  # closed-form function of time so frames can be sampled at any rate.
+  module Fx
+    Particle = Struct.new(:x, :y, :vx, :vy, :born, :life, :palette, :glyph, :gravity, :drag)
+
+    class Particles
+      attr_reader :list
+
+      def initialize(rng = Random.new)
+        @rng = rng
+        @list = []
+      end
+
+      def clear = @list.clear
+      def empty? = @list.empty?
+
+      # speed in cells/sec; y velocity is squashed to respect the cell aspect
+      def burst(x, y, n, at:, speed: 20.0, spread: 1.0, life: 0.6, palette: Color::FIRE, glyphs: nil,
+                gravity: 18.0, angle: nil, arc: Math::PI * 2, drag: 1.5)
+        n.times do
+          a = angle ? angle + (@rng.rand - 0.5) * arc : @rng.rand * Math::PI * 2
+          s = speed * (0.35 + @rng.rand * 0.65 * spread)
+          g = glyphs && glyphs[@rng.rand(glyphs.size)]
+          @list << Particle.new(x, y, Math.cos(a) * s, Math.sin(a) * s * 0.5, at, life * (0.6 + @rng.rand * 0.4),
+                                palette, g, gravity, drag)
+        end
+        self
+      end
+
+      def add(x, y, vx, vy, at:, life:, palette:, glyph: nil, gravity: 0.0, drag: 0.0)
+        @list << Particle.new(x, y, vx, vy, at, life, palette, glyph, gravity, drag)
+      end
+
+      def prune(t)
+        @list.reject! { |p| t - p.born > p.life }
+      end
+
+      def alive?(t)
+        @list.any? { |p| t - p.born <= p.life }
+      end
+
+      def draw(canvas, t)
+        @list.each do |p|
+          age = t - p.born
+          next if age < 0 || age > p.life
+          x, y = position(p, age)
+          col = Color.ramp(p.palette, age / p.life)
+          if p.glyph
+            canvas.put(x, y, p.glyph, col, bold: age < p.life * 0.3)
+          else
+            canvas.dot(x * 2, y * 4, col)
+          end
+        end
+      end
+
+      def position(p, age)
+        if p.drag > 0
+          k = (1 - Math.exp(-p.drag * age)) / p.drag
+          [p.x + p.vx * k, p.y + p.vy * k + 0.5 * p.gravity * age * age * 0.25]
+        else
+          [p.x + p.vx * age, p.y + p.vy * age + 0.5 * p.gravity * age * age * 0.25]
+        end
+      end
+    end
+
+    module_function
+
+    def ease_out(t) = 1 - (1 - clamp01(t))**3
+    def ease_in(t) = clamp01(t)**3
+    def ease_out_back(t)
+      t = clamp01(t)
+      c1 = 1.70158
+      c3 = c1 + 1
+      1 + c3 * (t - 1)**3 + c1 * (t - 1)**2
+    end
+
+    def clamp01(t) = t < 0 ? 0.0 : (t > 1 ? 1.0 : t.to_f)
+
+    def phase(t, from, to)
+      clamp01((t - from) / (to - from))
+    end
+
+    def pixel_char
+      Term.glyph("█", "⣿", "#")
+    end
+
+    # Big bitmap text. color_fn.(x, y, i) -> rgb where i is the pixel column.
+    # scale doubles pixels horizontally for chunkier letters.
+    def big_text(canvas, text, x, y, color_fn, scale: 1, glitch: 0.0, rng: nil, reveal: 1.0, bg_fn: nil)
+      bm = Font.bitmap(text)
+      pc = pixel_char
+      width = bm[0].size
+      shown = (width * reveal).ceil
+      bm.each_with_index do |row, ry|
+        row.each_with_index do |on, rx|
+          next unless on
+          next if rx >= shown
+          ox = 0
+          if glitch > 0 && rng && rng.rand < glitch
+            ox = rng.rand(5) - 2
+          end
+          col = color_fn.(rx, ry, rx.fdiv([width - 1, 1].max))
+          scale.times do |s|
+            canvas.put(x + rx * scale + s + ox, y + ry, pc, col, bg: bg_fn&.(rx, ry))
+          end
+        end
+      end
+      width * scale
+    end
+
+    def text_fits?(text, w, scale = 1)
+      Font.width(text, scale: scale) <= w
+    end
+
+    # Largest scale (2, 1) that fits; nil if the big font does not fit at all.
+    def best_scale(text, w)
+      return 2 if text_fits?(text, w, 2) && Font.width(text, scale: 2) <= 110
+      return 1 if text_fits?(text, w, 1)
+      nil
+    end
+
+    def shockwave(canvas, cx, cy, age, speed: 40.0, palette: Color::GOLD, life: 0.5, rings: 2)
+      return if age < 0 || age > life
+      rings.times do |i|
+        a = age - i * 0.06
+        next if a < 0
+        canvas.ring(cx, cy, a * speed, Color.ramp(palette, a / life), density: 1.3)
+      end
+    end
+
+    def sparkles(canvas, t, rng_seed, count, palette: Color::GOLD, area: nil)
+      x0, y0, w, h = area || [0, 0, canvas.w, canvas.h]
+      r = Random.new(rng_seed)
+      stars = [Term.glyph("✦", "*"), Term.glyph("✧", "+"), "*", "+", "."]
+      count.times do |i|
+        px = x0 + r.rand(w)
+        py = y0 + r.rand(h)
+        period = 0.25 + r.rand * 0.5
+        ph = ((t + r.rand) / period) % 1.0
+        next if ph > 0.6
+        canvas.put(px, py, stars[i % stars.size], Color.ramp(palette, ph / 0.6), bold: ph < 0.2)
+      end
+    end
+
+    def number_with_commas(n)
+      s = n.abs.to_s
+      s = s.reverse.scan(/\d{1,3}/).join(",").reverse
+      n < 0 ? "-#{s}" : s
+    end
+  end
+end

data/lib/dopairb/game.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module Dopairb
+  # COMBO / CHARGE / SCORE bookkeeping. Points are toys: they reward rhythm
+  # and recovery, never code length or correctness.
+  class Game
+    CHARGE_MAX = 100.0
+    TYPING_WINDOW = 0.6
+    COMBO_MILESTONES = [3, 5, 10, 15, 20, 30, 50, 75, 100].freeze
+    COMBO_MEGA = [10, 25, 50, 100].freeze
+    EVAL_MILESTONES = [10, 50, 100, 500, 1000, 5000, 10_000].freeze
+
+    Event = Struct.new(:kind, :tier, :info, :flags, :gain, :combo, :streak, :score, keyword_init: true) do
+      def flag?(f) = flags.include?(f)
+    end
+
+    attr_reader :score, :combo, :max_combo, :evals, :successes, :failures, :interrupts,
+                :charge, :error_streak, :record, :typing_combo, :started_at, :last_key_at,
+                :keystrokes, :best_typing
+
+    def initialize(clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })
+      @clock = clock
+      @started_at = now
+      @score = 0
+      @combo = 0
+      @max_combo = 0
+      @evals = 0
+      @successes = 0
+      @failures = 0
+      @interrupts = 0
+      @charge = 0.0
+      @error_streak = 0
+      @record = nil
+      @typing_combo = 0
+      @best_typing = 0
+      @last_key_at = nil
+      @last_char = nil
+      @same_char = 0
+      @typing_points = 0
+      @keystrokes = 0
+    end
+
+    def now = @clock.call
+
+    def multiplier(t = nil)
+      return 1.0 if t && (@last_key_at.nil? || t - @last_key_at > TYPING_WINDOW * 2)
+      1.0 + [@typing_combo, 50].min / 25.0
+    end
+
+    def heat(t = now)
+      return 0.0 unless @last_key_at
+      idle = t - @last_key_at
+      base = [@charge / CHARGE_MAX, @typing_combo / 30.0].max.clamp(0.0, 1.0)
+      base * Math.exp(-[idle - 1.0, 0].max / 4.0)
+    end
+
+    # kind: :insert, :delete, :move, :bracket, :string, :block, :complete, :history, :newline, :paste
+    # Returns :resume when typing restarts after a pause, else nil.
+    def key(kind, char = nil)
+      t = now
+      resumed = @last_key_at && t - @last_key_at > 2.0 && kind == :insert
+      if @last_key_at && t - @last_key_at <= TYPING_WINDOW
+        @typing_combo += 1 unless kind == :move
+      else
+        @typing_combo = kind == :move ? 0 : 1
+      end
+      @best_typing = @typing_combo if @typing_combo > @best_typing
+      @last_key_at = t
+      @keystrokes += 1 unless kind == :paste
+
+      gain, pts = case kind
+                  when :insert then [2.2, 1]
+                  when :delete then [0.6, 0]
+                  when :move then [0.2, 0]
+                  when :bracket then [6.0, 15]
+                  when :string then [4.0, 10]
+                  when :block then [9.0, 25]
+                  when :complete then [5.0, 20]
+                  when :history then [3.0, 5]
+                  when :newline then [8.0, 10]
+                  when :paste then [10.0, 10]
+                  else [0.0, 0]
+                  end
+      if kind == :insert
+        if char == @last_char
+          @same_char += 1
+        else
+          @same_char = 0
+          @last_char = char
+        end
+        gain *= 0.35**[@same_char, 4].min
+        pts = 0 if @same_char > 2
+      end
+      @charge += gain * (1 - @charge / CHARGE_MAX)
+      @charge = CHARGE_MAX if @charge > CHARGE_MAX
+      if @typing_points < 200
+        p = (pts * multiplier).round
+        @typing_points += p
+        @score += p
+      end
+      resumed ? :resume : nil
+    end
+
+    def success(info, code: "", out_lines: 0)
+      @evals += 1
+      @successes += 1
+      flags = []
+      flags << :first_hit if @successes == 1
+      flags << :comeback if @error_streak > 0
+      streak = @error_streak
+      @error_streak = 0
+      @combo += 1
+      @max_combo = @combo if @combo > @max_combo
+      flags << :combo_milestone if COMBO_MILESTONES.include?(@combo)
+      flags << :combo_mega if COMBO_MEGA.include?(@combo)
+      flags << :eval_milestone if EVAL_MILESTONES.include?(@evals)
+      flags << :output_rain if out_lines >= 20
+
+      if (num = numeric(info))
+        if @record && num > @record && num >= 100
+          flags << :new_record
+          flags << :record_jump if @record <= 0 ? num >= 1000 : num >= @record * 2
+        end
+        @record = num if @record.nil? || num > @record
+      end
+
+      gain = 100 + [@combo - 1, 40].min * 25 + (@charge * 2).round
+      gain += 500 if flags.include?(:comeback)
+      gain += 100 if flags.include?(:first_hit)
+      gain += 300 if flags.include?(:new_record)
+      gain += 1000 if flags.include?(:eval_milestone)
+      gain += @combo * 20 if flags.include?(:combo_milestone)
+      @score += gain
+      @charge = 0.0
+      @typing_points = 0
+
+      Event.new(kind: info[:type] == :definition ? :definition : :success, tier: nil, info: info, flags: flags,
+                gain: gain, combo: @combo, streak: streak, score: @score)
+    end
+
+    def failure(info)
+      @evals += 1
+      @failures += 1
+      @error_streak += 1
+      broken = @combo
+      @combo = 0
+      @charge = 0.0
+      @typing_points = 0
+      flags = []
+      flags << :combo_break if broken >= 3
+      flags << :eval_milestone if EVAL_MILESTONES.include?(@evals)
+      Event.new(kind: :failure, tier: nil, info: info.merge(broken_combo: broken), flags: flags, gain: 0,
+                combo: 0, streak: @error_streak, score: @score)
+    end
+
+    def interrupted
+      @interrupts += 1
+      lost = @charge
+      @charge = 0.0
+      @typing_points = 0
+      Event.new(kind: :interrupt, tier: nil, info: { charge: lost }, flags: [], gain: 0, combo: @combo,
+                streak: @error_streak, score: @score)
+    end
+
+    def elapsed = now - @started_at
+
+    def stats
+      { evals: @evals, successes: @successes, failures: @failures, interrupts: @interrupts,
+        max_combo: @max_combo, score: @score, keystrokes: @keystrokes, best_typing: @best_typing,
+        time: elapsed }
+    end
+
+    private
+
+    def numeric(info)
+      case info[:type]
+      when :integer then info[:value]
+      when :float then info[:value].finite? ? info[:value] : nil
+      end
+    end
+  end
+end