agentix-cli 0.96.1 → 0.97.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,137 @@
+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, and how far
+    /// it has turned (radians).
+    struct Piece: Equatable {
+        var from: Rect
+        var at: Point
+        var turn = 0.0
+    }
+
+    /// 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 stops on the
+    /// bottom of the picture and 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)
+        let x = min(max(source.x + v.x * s, 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), 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):
+                f.pieces.append(P.thrown(cut.source, v: v, spin: spin, rise: rise, after: f.t - cut.start, width: size.x, height: size.y))
+            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)))
+            }
+        }
+    }
+
+    /// 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
@@ -104,7 +91,7 @@ struct Play {
     typealias P = PlayMath
     typealias M = CharacterMath
 
-    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,17 +113,23 @@ 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
         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)
@@ -147,7 +140,18 @@ struct Play {
             let m = add(.jump, to: to, 0.5 + hypot(to.x - at.x, to.y - at.y) / 900)
             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 +178,49 @@ 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)
+                for (k, letter) in P.letters(of: word).enumerated() {
+                    throwing(letter, line: i, at: m.start + 0.25, 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), 0.5 + hypot(home.maxX - 4 - at.x, home.y - at.y) / 900, 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 {
@@ -188,10 +229,16 @@ struct Play {
         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 {
+        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)
+        // 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
@@ -203,14 +250,18 @@ struct Play {
         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:
+        case .jump, .carry:
             let air = sin(.pi * p)
             f.pose.sy *= 1 + 0.12 * air; f.pose.sx *= 1 - 0.08 * air
         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 +281,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/PlayStage.swift

@@ -1,16 +1,27 @@
 import AppKit
 
 /// What play mode (#505) draws over the picture: the page's colour where
-/// words are gone, the cloth, and the character. The context is flipped,
+/// words are gone, the pieces that moved, the cloth, and the character. The context is flipped,
 /// in the picture's points.
 enum PlayDraw {
-    static func draw(_ frame: Play.Frame, in ctx: CGContext, stops: [NSColor]) {
+    static func draw(_ frame: Play.Frame, in ctx: CGContext, stops: [NSColor], picture: CGImage?, scale: CGFloat) {
         for gone in frame.gone {
             let c = gone.paper
             ctx.setFillColor(CGColor(srgbRed: CGFloat(c >> 16 & 0xFF) / 255, green: CGFloat(c >> 8 & 0xFF) / 255,
                                      blue: CGFloat(c & 0xFF) / 255, alpha: 1))
             ctx.fill(cg(gone.rect))
         }
+        for piece in frame.pieces {
+            let from = cg(piece.from)
+            guard let part = picture?.cropping(to: from.applying(CGAffineTransform(scaleX: scale, y: scale))) else { continue }
+            ctx.saveGState()
+            ctx.translateBy(x: piece.at.x + from.width / 2, y: piece.at.y + from.height / 2)
+            ctx.rotate(by: piece.turn)
+            // The context is flipped; a picture is not.
+            ctx.scaleBy(x: 1, y: -1)
+            ctx.draw(part, in: CGRect(x: -from.width / 2, y: -from.height / 2, width: from.width, height: from.height))
+            ctx.restoreGState()
+        }
         if let cloth = frame.cloth {
             let path = CGPath(roundedRect: cg(cloth), cornerWidth: 4, cornerHeight: 4, transform: nil)
             ctx.addPath(path)
@@ -73,6 +84,7 @@ final class PlayHost {
         backdrop.layer?.contents = picture
         let view = PlayView(frame: bounds)
         view.stops = stops
+        view.picture = picture
         view.shown = Play.Frame(at: foot, pose: CharacterMath.pose(.working))
         view.onInput = { [weak self] in self?.end("a key or a click") }
         backdrop.addSubview(view)
@@ -144,6 +156,8 @@ private final class PlayWindow: NSPanel {
 private final class PlayView: NSView {
     var shown = Play.Frame()
     var stops = CharacterDraw.stops(tint: Brand.accent, colors: nil)
+    /// The picture under it: moved pieces are cut from it.
+    var picture: CGImage?
     var onInput: (() -> Void)?
 
     override var isFlipped: Bool { true }
@@ -152,7 +166,8 @@ private final class PlayView: NSView {
 
     override func draw(_ dirtyRect: NSRect) {
         guard let ctx = NSGraphicsContext.current?.cgContext else { return }
-        PlayDraw.draw(shown, in: ctx, stops: stops)
+        PlayDraw.draw(shown, in: ctx, stops: stops, picture: picture,
+                      scale: CGFloat(picture?.width ?? 0) / max(bounds.width, 1))
     }
 
     override func keyDown(with event: NSEvent) { onInput?() }

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

@@ -57,6 +57,8 @@ struct LookSection: View {
     @Binding var look: String
     /// Nil hides the control: the daemon is older than the reduced pill.
     var startReduced: Binding<Bool>?
+    /// Nil hides the control: the daemon is older than the stroll.
+    var stroll: Binding<Bool>?
 
     var body: some View {
         Section {
@@ -68,6 +70,10 @@ struct LookSection: View {
                 Toggle("Start reduced to the orb", isOn: startReduced)
                     .disabled(look == "character")
             }
+            if let stroll {
+                Toggle("Character strolls when idle", isOn: stroll)
+                    .disabled(look != "character")
+            }
         } header: {
             Text("Assistant")
         } footer: {

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

@@ -378,7 +378,10 @@ private struct GeneralTab: View {
                                               set: { model.draft?.general.look = $0 }),
                                 startReduced: draft.general.startReduced == nil ? nil
                                     : Binding(get: { model.draft?.general.startReduced ?? false },
-                                              set: { model.draft?.general.startReduced = $0 }))
+                                              set: { model.draft?.general.startReduced = $0 }),
+                                stroll: draft.general.stroll == nil ? nil
+                                    : Binding(get: { model.draft?.general.stroll ?? false },
+                                              set: { model.draft?.general.stroll = $0 }))
                 }
                 if draft.general.card != nil {
                     AnswerCardSection(card: Binding(get: { model.draft?.general.card ?? .standard },

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

@@ -32,13 +32,17 @@ struct VoiceSettings: Codable, Equatable {
         /// The pill starts reduced to its orb. Nil from a daemon older
         /// than the reduced pill.
         var startReduced: Bool?
+        /// The character takes a stroll when it has nothing to do. Nil
+        /// from a daemon older than the stroll.
+        var stroll: Bool?
 
         init(provider: String, fallback: String, stt: String, localStt: String = "mlx-whisper",
              endOfTurn: String = "vad", hotkeys: Hotkeys, card: Card? = nil, look: String? = nil,
-             startReduced: Bool? = nil) {
+             startReduced: Bool? = nil, stroll: Bool? = nil) {
             self.provider = provider; self.fallback = fallback; self.stt = stt
             self.localStt = localStt; self.endOfTurn = endOfTurn; self.hotkeys = hotkeys
             self.card = card; self.look = look; self.startReduced = startReduced
+            self.stroll = stroll
         }
 
         /// A daemon from before these fields leaves them out: the defaults.
@@ -53,6 +57,7 @@ struct VoiceSettings: Codable, Equatable {
             card = try c.decodeIfPresent(Card.self, forKey: .card)
             look = try c.decodeIfPresent(String.self, forKey: .look)
             startReduced = try c.decodeIfPresent(Bool.self, forKey: .startReduced)
+            stroll = try c.decodeIfPresent(Bool.self, forKey: .stroll)
         }
     }
     struct Voice: Codable, Equatable {
@@ -113,6 +118,7 @@ struct VoiceSettings: Codable, Equatable {
         if self.general.endOfTurn != old.general.endOfTurn { general["endOfTurn"] = self.general.endOfTurn }
         if let look = self.general.look, look != old.general.look { general["look"] = look }
         if let start = self.general.startReduced, start != old.general.startReduced { general["startReduced"] = start }
+        if let stroll = self.general.stroll, stroll != old.general.stroll { general["stroll"] = stroll }
         var keys: [String: Any] = [:]
         if self.general.hotkeys.talk != old.general.hotkeys.talk { keys["talk"] = self.general.hotkeys.talk }
         if self.general.hotkeys.stop != old.general.hotkeys.stop { keys["stop"] = self.general.hotkeys.stop }
@@ -157,6 +163,17 @@ struct VoiceSettings: Codable, Equatable {
         min(30, pow(2, Double(max(1, failures))))
     }
 
+    /// Seconds between reads once the daemon has answered, so a change
+    /// made outside the app shows without a restart.
+    static let rereadDelay: Double = 5
+
+    /// Whether a read from the daemon replaces what the app holds: it
+    /// differs, and nothing was saved here while it was on its way. A read
+    /// that started before a save in the window carries the old settings.
+    static func replaces(_ read: VoiceSettings, held: VoiceSettings?, heldWhenAsked: VoiceSettings?) -> Bool {
+        held == heldWhenAsked && read != held
+    }
+
     /// The fields a preview speaks with: the draft's voice for one agent.
     func previewVoice(for id: String) -> [String: Any] {
         guard let v = agents.first(where: { $0.id == id })?.voice else { return [:] }