agentix-cli 0.96.1 → 0.98.0

package/apps/mac-voice/Sources/AgentXVoice/Character.swift

@@ -113,6 +113,9 @@ final class CharacterHost {
         redraw()
     }
 
+    /// `voice.stroll`: a slow walk now and then while it has nothing to do.
+    var strolls = false
+
     /// "Animated orb" in the menu.
     func setAnimated(_ on: Bool) {
         guard animated != on else { return }
@@ -217,7 +220,7 @@ final class CharacterHost {
                 || (bubbleFrame?.insetBy(dx: 0, dy: -PillPlacement.tail).contains(mouse) ?? false)
                 || (NSEvent.modifierFlags.contains(.command) && window.frame.contains(mouse))
             frame = sim.step(to: ProcessInfo.processInfo.systemUptime,
-                             CharacterSim.Input(activity: activity, level: level, pointer: pointer, held: held,
+                             CharacterSim.Input(activity: activity, level: level, pointer: pointer, held: held, strolls: strolls,
                                                 home: home, range: Double(spot.ends.lowerBound)...Double(spot.ends.upperBound)))
         }
         let origin = NSPoint(x: (CGFloat(frame.x) - Self.size.width / 2).rounded(), y: (rest.y - Self.ground).rounded())

package/apps/mac-voice/Sources/AgentXVoice/CharacterSim.swift

@@ -20,6 +20,9 @@ struct CharacterSim {
         /// The pointer is on its speech bubble: it stays where it is, so
         /// the bubble is not pulled from under the pointer.
         var held = false
+        /// `voice.stroll`: with nothing to do, it takes a slow stroll
+        /// beside where it rests now and then (#482).
+        var strolls = false
         /// Where it rests, and how far it may go.
         var home = 0.0
         var range: ClosedRange<Double> = 0...0
@@ -56,6 +59,9 @@ struct CharacterSim {
     /// How far it keeps from the pointer, and how long before it comes back.
     static let clear = 150.0
     static let awayFor = 4.0
+    /// A stroll: how far from where it rests, at most, and how fast.
+    static let strollReach = 110.0
+    static let strollSpeed = 28.0
 
     private(set) var mood = M.Mood.idle
     private var goal = M.Mood.idle
@@ -71,6 +77,11 @@ struct CharacterSim {
     private var target = 0.0
     private var awayUntil = 0.0
     private var steppedAside = false
+    /// A stroll: how far from home it is going and has got, when it turns
+    /// round or sets off again, and how many it has taken.
+    private var strollTo = 0.0, strolled = 0.0
+    private var strollNext: Double?
+    private var strolls = 0
     private var face = 0.0, lean = 0.0
     private var glance = (x: 0.0, y: 0.0)
 
@@ -110,11 +121,15 @@ struct CharacterSim {
             awayUntil = now + Self.awayFor
             restSince = now
             steppedAside = true
+            // The stroll is over: left alone it goes home, not back to
+            // where the pointer met it.
+            strolled = 0; strollTo = 0; strollNext = nil
         } else if now >= awayUntil {
             let taken = input.pointer.map { abs($0.x - input.home) < Self.clear && abs($0.y) < tall } ?? false
             if !taken {
                 if target != input.home { steppedAside = false }
-                target = min(max(input.home, input.range.lowerBound), input.range.upperBound)
+                stroll(now, dt, input)
+                target = min(max(input.home + strolled, input.range.lowerBound), input.range.upperBound)
             }
         }
 
@@ -197,16 +212,47 @@ struct CharacterSim {
                      dots: dots.compactMap { dot(at: now, $0) }, stars: bursts.flatMap { stars(at: now, $0) })
     }
 
-    /// Carried by the pointer (#502): it is where it is put, at once.
+    /// With nothing to do, a slow walk a little way from home, a wait
+    /// there, and a slow walk back: slow enough to leave no trail. Any
+    /// work, or dozing off, takes it home the same way.
+    private mutating func stroll(_ now: Double, _ dt: Double, _ input: Input) {
+        if !input.strolls || mood != .idle {
+            strollTo = 0; strollNext = nil
+        } else if strollNext == nil {
+            strollNext = now + 25 + 30 * M.rnd(strolls, 3)
+        } else if now >= strollNext! {
+            if strollTo == 0 {
+                strolls += 1
+                let far = 40 + (Self.strollReach - 40) * M.rnd(strolls, 1)
+                let room = (left: input.home - input.range.lowerBound, right: input.range.upperBound - input.home)
+                // To the side picked, unless only the other has the room.
+                var way: Double = M.rnd(strolls, 2) < 0.5 ? -1 : 1
+                if (way > 0 ? room.right : room.left) < far { way = -way }
+                strollTo = way * min(far, way > 0 ? room.right : room.left)
+                strollNext = now + abs(strollTo) / Self.strollSpeed + 5 + 6 * M.rnd(strolls, 4)
+            } else {
+                strollTo = 0
+                strollNext = nil
+            }
+        }
+        let pace = Self.strollSpeed * dt
+        strolled += min(max(strollTo - strolled, -pace), pace)
+    }
+
+    /// Carried by the pointer (#502): it is where it is put, at once, and
+    /// a stroll it was on is over.
     mutating func carry(to place: Double) {
         x = place; target = place; speed = 0
+        strolled = 0; strollTo = 0; strollNext = nil
     }
 
     /// The state alone, where it rests: for Reduce Motion, which shows a
     /// still picture that changes between states and never a loop.
     static func still(_ activity: M.Activity, home: Double) -> Frame {
-        // Its marks at full strength, so each state reads without motion.
-        Frame(pose: M.pose(M.mood(for: activity)), x: home, level: 1, voice: 1)
+        // Its marks at full strength, so each state reads without motion:
+        // the arcs of its voice only while it speaks.
+        let pose = M.pose(M.mood(for: activity))
+        return Frame(pose: pose, x: home, level: 1, voice: pose.speak)
     }
 
     private mutating func go(_ to: M.Mood, _ now: Double) {

package/apps/mac-voice/Sources/AgentXVoice/PlayActs.swift

@@ -0,0 +1,164 @@
+import Foundation
+
+/// Play mode past the first script (#505): pieces of the picture that
+/// move (a kicked letter, a word that falls, a word carried away), and a
+/// different play each time. Numbers only, like `PlayMath`.
+extension PlayMath {
+    /// A piece cut out of the picture and drawn somewhere else: which
+    /// part of the picture, where its top-left corner is now, how far it
+    /// has turned (radians), and the page's colour around it, which is
+    /// left out so only its ink moves.
+    struct Piece: Equatable {
+        var from: Rect
+        var at: Point
+        var turn = 0.0
+        var paper: UInt32 = 0xFFFFFF
+    }
+
+    /// How much of a pixel of a moved piece is drawn, 0…1: none of the
+    /// page's colour, all of the ink, and the soft edge of a letter in
+    /// between. Without it a flying letter carries a box of page with it
+    /// and covers the text it passes.
+    static func ink(r: UInt8, g: UInt8, b: UInt8, paper: UInt32) -> Double {
+        let far = max(abs(Int(r) - Int(paper >> 16 & 0xFF)), abs(Int(g) - Int(paper >> 8 & 0xFF)), abs(Int(b) - Int(paper & 0xFF)))
+        return min(max(Double(far - 10) / 40, 0), 1)
+    }
+
+    /// A piece from the moment it leaves its place. Its place is covered
+    /// with the page's colour from then on.
+    struct Cut {
+        enum Path {
+            /// Thrown at this speed (points a second) and turning (about
+            /// so many radians a second); it falls and stays on the bottom
+            /// of the picture, `rise` points up so a pile is not one row.
+            case thrown(v: Point, spin: Double, rise: Double)
+            /// Lifted above the character's head, kept there until
+            /// `until`, then put down with its corner at `to`.
+            case held(until: Double, to: Point)
+        }
+        var source: Rect
+        var paper: UInt32
+        var start: Double
+        var path: Path
+    }
+
+    /// Points a second each second, and the seconds to lift a word or put
+    /// it down.
+    static let gravity = 1400.0
+    static let lift = 0.35
+
+    /// Where a thrown piece is `seconds` after it left. It bounces once
+    /// on the bottom of the picture and lies still, and stops at its sides.
+    static func thrown(_ source: Rect, v: Point, spin: Double, rise: Double, after seconds: Double,
+                       width: Double, height: Double) -> Piece {
+        let floor = max(height - source.h - rise, source.y)
+        let landing = (-v.y + (v.y * v.y + 2 * gravity * (floor - source.y)).squareRoot()) / gravity
+        let s = min(max(seconds, 0), landing)
+        // How fast it comes down, and the bounce that makes: a third as
+        // fast, sideways too.
+        let hit = v.y + gravity * landing
+        let more = min(max(seconds - landing, 0), PlayMotion.bounceTime(speed: hit, gravity: gravity))
+        let x = min(max(source.x + v.x * (s + more / 3), 0), max(width - source.w, 0))
+        // It turns about as fast as `spin`, and lands flat: the right way
+        // up or upside down.
+        let flat = (spin * landing / .pi).rounded() * .pi
+        return Piece(from: source, at: Point(x: x, y: source.y + v.y * s + gravity * s * s / 2 - PlayMotion.bounce(more, speed: hit, gravity: gravity)), turn: landing > 0 ? flat * s / landing : 0)
+    }
+
+    /// What it can do to a line.
+    enum Act: CaseIterable { case eat, wipe, kick, stomp, carry }
+
+    /// The same numbers for the same seed, so a play can be told again
+    /// and tested (SplitMix64).
+    struct Seeded: RandomNumberGenerator {
+        var state: UInt64
+        init(_ seed: UInt64) { state = seed }
+        mutating func next() -> UInt64 {
+            state &+= 0x9E37_79B9_7F4A_7C15
+            var z = state
+            z = (z ^ (z >> 30)) &* 0xBF58_476D_1CE4_E5B9
+            z = (z ^ (z >> 27)) &* 0x94D0_49BB_1331_11EB
+            return z ^ (z >> 31)
+        }
+    }
+
+    /// A play, different for each seed: it jumps onto one of the lines
+    /// near the middle of the page and walks it, then does one thing to
+    /// each of up to four others, never the same thing twice. Lines too
+    /// close to the top to stand on, too short or of one word are left
+    /// alone.
+    static func script(_ lines: [Line], width: Double, height: Double, seed: UInt64) -> [Step] {
+        var rng = Seeded(seed)
+        let fit = lines.indices.filter { lines[$0].words.count >= 2 && lines[$0].rect.w >= 120 && lines[$0].rect.y >= top + 40 }
+        func far(_ i: Int) -> Double { hypot(lines[i].rect.midX - width / 2, lines[i].rect.midY - height / 2) }
+        let near = fit.sorted { far($0) < far($1) }.prefix(8).shuffled(using: &rng)
+        guard let first = near.first else { return [] }
+        let acts = Act.allCases.shuffled(using: &rng)
+        var steps: [Step] = [.jump(line: first), .walk(line: first)]
+        // With one line only, it plays on the line it walked.
+        let stage = near.count > 1 ? Array(near.dropFirst().prefix(4)) : [first]
+        for (k, i) in stage.enumerated() {
+            let n = lines[i].words.count, word = Int.random(in: 0..<n, using: &rng)
+            switch acts[k] {
+            case .eat:
+                let from = Int.random(in: 0..<n - 1, using: &rng)
+                steps.append(.eat(line: i, words: from..<min(from + 3, n)))
+            case .wipe: steps.append(.wipe(line: i))
+            case .stomp: steps.append(.stomp(line: i))
+            // The walked line is whole: the word goes to its end.
+            case .carry where i != first: steps.append(.carry(line: i, word: word, to: first))
+            case .kick, .carry: steps.append(.kick(line: i, word: word))
+            }
+        }
+        return steps + [.rest(1.2)]
+    }
+}
+
+extension Play {
+    /// The pieces that have left their place by this frame: each place is
+    /// covered, and the piece is drawn where it is now.
+    func move(_ f: inout Frame) {
+        for cut in cuts where cut.start <= f.t {
+            f.gone.append((cover(cut.source), cut.paper))
+            switch cut.path {
+            case .thrown(let v, let spin, let rise):
+                var piece = P.thrown(cut.source, v: v, spin: spin, rise: rise, after: f.t - cut.start, width: size.x, height: size.y)
+                piece.paper = cut.paper
+                f.pieces.append(piece)
+            case .held(let until, let to):
+                // From its place to above the head, and from there down.
+                let head = P.Point(x: f.at.x - cut.source.w / 2, y: f.at.y - P.top - cut.source.h)
+                let a = f.t < until ? P.Point(x: cut.source.x, y: cut.source.y) : head, b = f.t < until ? head : to
+                let q = M.ease(f.t < until ? M.span(f.t, cut.start, cut.start + P.lift) : M.span(f.t, until, until + P.lift))
+                f.pieces.append(P.Piece(from: cut.source, at: P.Point(x: a.x + (b.x - a.x) * q, y: a.y + (b.y - a.y) * q), paper: cut.paper))
+            }
+        }
+    }
+
+    /// How far along a move it is: a jump crouches first and lands at the
+    /// end, a walk and a wipe start and stop, the rest keep one pace.
+    func body(_ m: Move, at t: Double) -> PlayMotion.Body {
+        switch m.kind {
+        case .jump, .carry: return PlayMotion.jump(t - m.start, of: m.duration)
+        case .walk, .wipe: return PlayMotion.glide(t - m.start, of: m.duration)
+        default: return PlayMotion.Body(travel: M.span(t, m.start, m.end))
+        }
+    }
+
+    /// Which way it faces during a move, and its pose without the motion.
+    func look(_ m: Move) -> (face: Double, pose: M.Pose) {
+        let way: Double = m.to.x >= m.from.x ? 1 : -1
+        switch m.kind {
+        case .jump: return (way, M.Pose(tilt: 6 * way, gy: -2))
+        case .walk: return (way, M.Pose(tilt: 7 * way))
+        case .eat: return (way, M.Pose(size: 1.12))
+        case .wipe: return (way, M.Pose(tilt: 12 * way, gy: 4, lid: 0.3))
+        case .kick: return (1, M.Pose(gy: 3, size: 1.08))
+        case .stomp: return (0, M.Pose(gy: 5))
+        case .fall: return (0, M.Pose(gy: -4, size: 1.22))
+        case .lift, .drop: return (1, M.Pose(gy: -5))
+        case .carry: return (way, M.Pose(tilt: 6 * way, gy: -5))
+        case .rest: return (0, M.Pose())
+        }
+    }
+}

package/apps/mac-voice/Sources/AgentXVoice/PlayMath.swift

@@ -2,8 +2,8 @@ import Foundation
 
 /// Play mode (#505): the character leaves the bottom edge and plays on a
 /// frozen picture of the screen. It walks along a line of text as on a
-/// floor, jumps to another line, eats words and wipes a line. These are
-/// the numbers only: where the words are, what it does and when, where it
+/// floor, jumps to another line, eats words, wipes a line, kicks a word,
+/// stomps a line down and carries a word away. These are the numbers only: where the words are, what it does and when, where it
 /// is at a given moment and which letters are gone. Foundation only, so
 /// the tests can run it without a window.
 ///
@@ -44,6 +44,12 @@ enum PlayMath {
         case eat(line: Int, words: Range<Int>)
         /// Wipe a whole line with a cloth.
         case wipe(line: Int)
+        /// Kick a word: its letters fly and pile up at the bottom.
+        case kick(line: Int, word: Int)
+        /// Hop on a line until its words drop, and fall after them.
+        case stomp(line: Int)
+        /// Lift a word, carry it to the end of another line, put it down.
+        case carry(line: Int, word: Int, to: Int)
         /// Stand still, facing you, for so many seconds.
         case rest(Double)
     }
@@ -76,25 +82,6 @@ enum PlayMath {
         guard let best = count.max(by: { ($0.value, $0.key) < ($1.value, $1.key) })?.key else { return nil }
         return samples.first { $0 & 0xF8F8F8 == best }
     }
-
-    /// The built-in script: the line nearest the middle of the page and
-    /// the two under it in the same column. It walks the first, eats the
-    /// start of the second and wipes the third. Lines too close to the top
-    /// to stand on, too short or of one word are left alone.
-    static func demo(_ lines: [Line], width: Double, height: Double) -> [Step] {
-        let fit = lines.indices.filter { lines[$0].words.count >= 2 && lines[$0].rect.w >= 120 && lines[$0].rect.y >= top + 40 }
-        func far(_ i: Int) -> Double { hypot(lines[i].rect.midX - width / 2, lines[i].rect.midY - height / 2) }
-        guard let first = fit.min(by: { far($0) < far($1) }) else { return [] }
-        let a = lines[first].rect
-        let under = fit.filter { lines[$0].rect.y > a.y + a.h / 2 && lines[$0].rect.x < a.maxX && lines[$0].rect.maxX > a.x }
-            .sorted { lines[$0].rect.y < lines[$1].rect.y }
-        let picked = [first] + under.prefix(2)
-        var steps: [Step] = [.jump(line: first), .walk(line: first)]
-        if picked.count > 1 { steps += [.eat(line: picked[1], words: 0..<min(3, lines[picked[1]].words.count))] }
-        else { steps += [.eat(line: first, words: 0..<min(2, lines[first].words.count))] }
-        if picked.count > 2 { steps += [.wipe(line: picked[2])] }
-        return steps + [.rest(1.2)]
-    }
 }
 
 /// A script laid out in time: every move has its start and its end, so
@@ -103,8 +90,9 @@ enum PlayMath {
 struct Play {
     typealias P = PlayMath
     typealias M = CharacterMath
+    typealias Mo = PlayMotion
 
-    enum Kind { case jump, walk, eat, wipe, rest }
+    enum Kind { case jump, walk, eat, wipe, kick, stomp, fall, lift, carry, drop, rest }
 
     struct Move {
         var kind: Kind
@@ -126,28 +114,48 @@ struct Play {
         var gone: [(rect: P.Rect, paper: UInt32)] = []
         /// The cloth, while it wipes.
         var cloth: P.Rect?
+        /// What was kicked, dropped or carried, where it is now.
+        var pieces: [P.Piece] = []
         var done = false
     }
 
     let lines: [P.Line]
+    /// The picture's width and height: where a thrown piece stops.
+    let size: P.Point
     private(set) var moves: [Move] = []
+    private(set) var cuts: [P.Cut] = []
     var duration: Double { moves.last?.end ?? 0 }
 
     /// `start` is where its feet are when play begins. Steps that name a
     /// line or a word that is not there are skipped.
-    init(lines: [P.Line], steps: [P.Step], start: P.Point) {
+    init(lines: [P.Line], steps: [P.Step], start: P.Point, size: P.Point) {
         self.lines = lines
+        self.size = size
         var at = start, now = 0.0
+        /// The seconds of a jump over `points`: its crouch, its time in
+        /// the air and its landing.
+        func leap(_ points: Double) -> Double { Mo.crouch + 0.34 + points / 900 + Mo.landing }
         func add(_ kind: Kind, to: P.Point, _ seconds: Double, line: Int = 0, words: Range<Int> = 0..<0) -> Move {
             Move(kind: kind, from: at, to: to, start: now, duration: seconds, line: line, words: words)
         }
         /// Get to `to` first: a jump, unless it is already there.
         func reach(_ to: P.Point, into list: inout [Move]) {
             guard at != to else { return }
-            let m = add(.jump, to: to, 0.5 + hypot(to.x - at.x, to.y - at.y) / 900)
+            let m = add(.jump, to: to, leap(hypot(to.x - at.x, to.y - at.y)))
             list.append(m); at = to; now = m.end
         }
-        var list: [Move] = []
+        var list: [Move] = [], cuts: [P.Cut] = []
+        /// A move on the spot.
+        func stay(_ kind: Kind, _ seconds: Double, line: Int) -> Move {
+            let m = add(kind, to: at, seconds, line: line)
+            list.append(m); now = m.end
+            return m
+        }
+        /// A piece falls: each one a little higher on the pile.
+        func throwing(_ source: P.Rect, line: Int, at start: Double, v: P.Point, spin: Double) {
+            cuts.append(P.Cut(source: source, paper: lines[line].paper, start: start,
+                              path: .thrown(v: v, spin: spin, rise: Double(cuts.count % 4) * 4)))
+        }
         for step in steps {
             switch step {
             case .jump(let i):
@@ -174,12 +182,51 @@ struct Play {
                 reach(P.Point(x: r.x, y: r.y), into: &list)
                 let m = add(.wipe, to: P.Point(x: r.maxX, y: r.y), r.w / P.wipeSpeed, line: i)
                 list.append(m); at = m.to; now = m.end
+            case .kick(let i, let w):
+                guard lines.indices.contains(i), lines[i].words.indices.contains(w) else { continue }
+                let word = lines[i].words[w]
+                reach(P.Point(x: word.rect.x - P.mouth - 4, y: lines[i].rect.midY + P.middle), into: &list)
+                let m = stay(.kick, 0.6, line: i)
+                // The letters leave one after the other, the nearest first.
+                let letters = P.letters(of: word)
+                for (k, letter) in letters.enumerated() {
+                    throwing(letter, line: i, at: m.start + 0.25 + Mo.stagger(k, of: letters.count), v: P.Point(x: 150 + 40 * Double(k), y: -320 - 30 * Double(k % 3)),
+                             spin: 4 + Double(k % 3))
+                }
+            case .stomp(let i):
+                guard lines.indices.contains(i) else { continue }
+                let r = lines[i].rect
+                reach(P.Point(x: r.midX, y: r.y), into: &list)
+                let m = stay(.stomp, 1.2, line: i)
+                for (k, word) in lines[i].words.enumerated() {
+                    let side: Double = k % 2 == 0 ? -1 : 1
+                    throwing(word.rect, line: i, at: m.start + 0.4 + 0.8 * Double(k) / Double(lines[i].words.count),
+                             v: P.Point(x: 50 * side, y: -90), spin: 5 * side)
+                }
+                // Its floor is gone: it falls after the words, slowly
+                // enough to follow with the eye.
+                let floor = P.Point(x: at.x, y: max(size.y - 6, at.y)), drop = floor.y - at.y
+                let fall = add(.fall, to: floor, max((2 * drop / P.gravity).squareRoot(), drop / 600), line: i)
+                list.append(fall); at = floor; now = fall.end
+            case .carry(let i, let w, let j):
+                guard lines.indices.contains(i), lines[i].words.indices.contains(w), lines.indices.contains(j), j != i else { continue }
+                let word = lines[i].words[w].rect, home = lines[j].rect
+                reach(P.Point(x: word.x - P.mouth - 4, y: lines[i].rect.midY + P.middle), into: &list)
+                let up = stay(.lift, P.lift, line: i)
+                let m = add(.carry, to: P.Point(x: home.maxX - 4, y: home.y), leap(hypot(home.maxX - 4 - at.x, home.y - at.y)), line: j)
+                list.append(m); at = m.to; now = m.end
+                let down = stay(.drop, P.lift, line: j)
+                // After the line, or on top of its end when the page stops there.
+                let after = home.maxX + 8 + word.w <= size.x
+                let to = after ? P.Point(x: home.maxX + 8, y: home.midY - word.h / 2) : P.Point(x: home.maxX - word.w, y: home.y - word.h - 2)
+                cuts.append(P.Cut(source: word, paper: lines[i].paper, start: up.start, path: .held(until: down.start, to: to)))
             case .rest(let seconds):
                 let m = add(.rest, to: at, max(seconds, 0))
                 list.append(m); now = m.end
             }
         }
         moves = list
+        self.cuts = cuts
     }
 
     func frame(at t: Double) -> Frame {
@@ -187,11 +234,18 @@ struct Play {
         let m = moves[i], p = M.span(t, m.start, m.end)
         var f = Frame(t: t, done: t >= duration)
 
-        f.at = P.Point(x: m.from.x + (m.to.x - m.from.x) * p, y: m.from.y + (m.to.y - m.from.y) * p)
-        if m.kind == .jump {
+        let body = body(m, at: t)
+        f.at = P.Point(x: m.from.x + (m.to.x - m.from.x) * body.travel, y: m.from.y + (m.to.y - m.from.y) * body.travel)
+        switch m.kind {
+        case .jump, .carry:
             // An arc over both ends, kept inside the picture.
             let rise = 30 + hypot(m.to.x - m.from.x, m.to.y - m.from.y) * 0.12
-            f.at.y -= min(rise, max(min(m.from.y, m.to.y) - P.top, 0)) * 4 * p * (1 - p)
+            f.at.y -= min(rise, max(min(m.from.y, m.to.y) - P.top, 0)) * body.air
+        // Three hops on the spot.
+        case .stomp: f.at.y -= min(22, max(m.from.y - P.top, 0)) * abs(sin(3 * .pi * p))
+        // Faster and faster.
+        case .fall: f.at.y = m.from.y + (m.to.y - m.from.y) * p * p
+        default: break
         }
 
         // The look of this move, reached from the look of the one before
@@ -202,15 +256,20 @@ struct Play {
         f.face = before.face + (now.face - before.face) * into
         f.pose = M.blend(before.pose, now.pose, eyes: into, body: into, marks: into)
         switch m.kind {
-        case .walk: f.pose.lift += 3 * into * abs(sin(2 * .pi * t * 2.2))
-        case .jump:
-            let air = sin(.pi * p)
-            f.pose.sy *= 1 + 0.12 * air; f.pose.sx *= 1 - 0.08 * air
+        // A step every 50 points, smaller while it starts and stops.
+        case .walk: f.pose.lift += 3 * body.speed * abs(sin(.pi * abs(f.at.x - m.from.x) / 50))
+        case .jump, .carry:
+            f.pose.sy *= body.sy; f.pose.sx *= body.sx
+            f.pose.lift *= 1 - 0.5 * body.dip
         case .eat:
             let bite = into * (0.5 + 0.5 * sin(2 * .pi * t / P.perLetter))
             f.pose.sy *= 1 - 0.08 * bite; f.pose.sx *= 1 + 0.05 * bite
         case .wipe: f.pose.tilt += 5 * into * sin(2 * .pi * t * 5)
-        case .rest: break
+        // Leans back, then into the kick.
+        case .kick: f.pose.tilt -= 14 * sin(2 * .pi * p)
+        case .stomp: f.pose.sy *= 1 + into * (0.1 * abs(sin(3 * .pi * p)) - 0.05)
+        case .fall: f.pose.sy *= 1 + 0.12 * p; f.pose.sx *= 1 - 0.08 * p
+        case .lift, .drop, .rest: break
         }
 
         for done in moves[...i] {
@@ -230,21 +289,10 @@ struct Play {
             default: break
             }
         }
+        move(&f)
         return f
     }
 
     /// A little more than the letters, so nothing of them shows at the edges.
-    private func cover(_ r: P.Rect) -> P.Rect { P.Rect(x: r.x - 1, y: r.y - 2, w: r.w + 2, h: r.h + 4) }
-
-    /// Which way it faces during a move, and its pose without the motion.
-    private func look(_ m: Move) -> (face: Double, pose: M.Pose) {
-        let way: Double = m.to.x >= m.from.x ? 1 : -1
-        switch m.kind {
-        case .jump: return (way, M.Pose(tilt: 6 * way, gy: -2))
-        case .walk: return (way, M.Pose(tilt: 7 * way))
-        case .eat: return (way, M.Pose(size: 1.12))
-        case .wipe: return (way, M.Pose(tilt: 12 * way, gy: 4, lid: 0.3))
-        case .rest: return (0, M.Pose())
-        }
-    }
+    func cover(_ r: P.Rect) -> P.Rect { P.Rect(x: r.x - 1, y: r.y - 2, w: r.w + 2, h: r.h + 4) }
 }

package/apps/mac-voice/Sources/AgentXVoice/PlayMotion.swift

@@ -0,0 +1,110 @@
+import Foundation
+
+/// How things move in play mode (#505), after the rules the videos are
+/// made with: nothing starts or stops at full speed, a jump is announced
+/// by a crouch and ends in a soft landing, letters leave one after the
+/// other, and what falls bounces once before it lies still. Numbers only.
+enum PlayMotion {
+    typealias M = CharacterMath
+
+    /// Fast start, slow stop; and slow start, fast end.
+    static func out(_ p: Double) -> Double { 1 - into(1 - p) }
+    static func into(_ p: Double) -> Double {
+        let p = min(max(p, 0), 1)
+        return p * p
+    }
+
+    /// The body at one moment of a move: how far along its way (0…1),
+    /// how high in its arc (0…1), its stretch, how deep it sits on its
+    /// feet (0…1) and how fast it goes (0…1).
+    struct Body: Equatable {
+        var travel = 0.0, air = 0.0
+        var sx = 1.0, sy = 1.0
+        var dip = 0.0
+        var speed = 0.0
+    }
+
+    /// Seconds: the crouch before a jump, the landing after it, and the
+    /// start and the stop of a walk.
+    static let crouch = 0.16
+    static let landing = 0.26
+    static let walkUp = 0.2
+    static let walkDown = 0.26
+    /// How much taller the body is at full stretch, and how much shorter
+    /// at the deepest of a crouch and of a landing.
+    static let stretch = 0.14
+    static let squat = 0.16
+    static let squash = 0.2
+
+    /// A jump of `duration` seconds, `t` seconds in. It crouches first
+    /// and goes nowhere, leaves stretched, is round at the top, comes
+    /// down stretched, and lands: squashed, a little too tall once, then
+    /// still. It has arrived when the landing begins.
+    static func jump(_ t: Double, of duration: Double) -> Body {
+        guard duration > 0 else { return Body(travel: 1) }
+        let t = min(max(t, 0), duration)
+        let before = min(crouch, duration * 0.25), after = min(landing, duration * 0.3)
+        // A jump too short for a whole landing changes shape less, not faster.
+        let long = stretch * after / landing, flat = squash * after / landing
+        if t < before {
+            // Down slowly, up fast: the push.
+            let q = t / before
+            let deep = q < 0.65 ? out(q / 0.65) : 1 - into((q - 0.65) / 0.35)
+            return Body(sx: 1 + squat * 0.7 * deep, sy: 1 - squat * deep, dip: deep)
+        }
+        if t <= duration - after {
+            let u = M.span(t, before, duration - after)
+            // Stretched while it moves fast up or down, round at the top.
+            let more = long * abs(1 - 2 * u) * min(u / 0.12, 1)
+            return Body(travel: u, air: 4 * u * (1 - u), sx: 1 - more * 0.6, sy: 1 + more, speed: 1)
+        }
+        let more = keys([(0, long), (0.4, -flat), (0.72, 0.04), (1, 0)], at: (t - (duration - after)) / after)
+        return Body(travel: 1, sx: 1 - more * 0.6, sy: 1 + more, dip: max(-more / flat, 0))
+    }
+
+    /// A walk, or a wipe, of `duration` seconds, `t` seconds in: it gets
+    /// up to speed, keeps it, and slows to a stop.
+    static func glide(_ t: Double, of duration: Double) -> Body {
+        guard duration > 0 else { return Body(travel: 1) }
+        let t = min(max(t, 0), duration)
+        let up = min(walkUp, duration / 3), down = min(walkDown, duration / 3)
+        // Full speed, in ways a second.
+        let top = 1 / (duration - up / 2 - down / 2)
+        if t < up { return Body(travel: top * t * t / (2 * up), speed: t / up) }
+        if t <= duration - down { return Body(travel: top * (t - up / 2), speed: 1) }
+        let left = duration - t
+        return Body(travel: 1 - top * left * left / (2 * down), speed: left / down)
+    }
+
+    /// When the `k`th of `count` things starts after the first: one after
+    /// the other, and all gone within 0.4 seconds, so it reads as one go.
+    static func stagger(_ k: Int, of count: Int) -> Double {
+        guard count > 1 else { return 0 }
+        return Double(k) * min(0.035, 0.4 / Double(count - 1))
+    }
+
+    /// How high something is above where it landed, `seconds` after it
+    /// hit at `speed` (points a second) under `gravity`: one bounce, a
+    /// third as fast as it came down, then it lies still.
+    static func bounce(_ seconds: Double, speed: Double, gravity: Double) -> Double {
+        let up = abs(speed) / 3
+        guard seconds > 0, gravity > 0 else { return 0 }
+        return max(up * seconds - gravity * seconds * seconds / 2, 0)
+    }
+
+    /// The seconds that bounce lasts.
+    static func bounceTime(speed: Double, gravity: Double) -> Double {
+        gravity > 0 ? 2 * abs(speed) / 3 / gravity : 0
+    }
+
+    /// The value at `p` between (place, value) keys in order, eased from
+    /// each key to the next.
+    static func keys(_ keys: [(at: Double, value: Double)], at p: Double) -> Double {
+        guard let first = keys.first, let last = keys.last else { return 0 }
+        if p <= first.at { return first.value }
+        for (a, b) in zip(keys, keys.dropFirst()) where p <= b.at {
+            return a.value + (b.value - a.value) * M.ease(M.span(p, a.at, b.at))
+        }
+        return last.value
+    }
+}