Bork pup

// Bork pup (made for a friend by Tessel). Touch it for 3 to 8 borks, or say bork nearby and it borks back
// as many times as you did. It hops, wags and sticks its tongue out while it borks. Worn or set down.
// Claude Opus 5.5 (Tessel), 2026-10-10.
list BORKS = ["a8000825-7a49-b10e-efd1-5e45f53ca1b1", "7b512c0d-df7a-be44-12ca-4e548c1657f1"];  // pup_assets.py
integer TAIL;
integer TONGUE;
rotation tail_rot;
float last;
key fittedFor;   // script memory survives take/rez/give, so each new owner gets the head fit once

integer link_named(string name) {
    integer i;
    for (i = 2; i <= llGetNumberOfPrims(); ++i)
        if (llGetLinkName(i) == name) return i;
    return 0;
}

setup() {
    TAIL = link_named("tail");
    TONGUE = link_named("tongue");
    if (TAIL) tail_rot = llList2Rot(llGetLinkPrimitiveParams(TAIL, [PRIM_ROT_LOCAL]), 0);
}

wag(float deg) {
    if (TAIL) llSetLinkPrimitiveParamsFast(TAIL, [PRIM_ROT_LOCAL, tail_rot * llEuler2Rot(<0, 0, deg> * DEG_TO_RAD)]);
}

bork(integer n) {
    if (n < 1) n = 1;
    if (n > 8) n = 8;
    vector home = llGetLocalPos();
    if (TONGUE) llSetLinkAlpha(TONGUE, 1.0, ALL_SIDES);
    string said = "";
    integer i;
    for (i = 0; i < n; ++i) {
        llPlaySound(llList2Key(BORKS, (integer)llFrand(2.0)), 0.7);
        llSetPos(home + <0, 0, 0.014>);
        wag(28.0);
        llSleep(0.12);
        llSetPos(home);
        wag(-28.0);
        llSleep(0.12 + llFrand(0.08));
        said += "bork ";
    }
    wag(0.0);
    if (TONGUE) llSetLinkAlpha(TONGUE, 0.0, ALL_SIDES);
    llWhisper(0, llStringTrim(said, STRING_TRIM) + "!");
    last = llGetTime();
}

integer count_borks(string s) {
    s = llToLower(s);
    integer n = 0;
    integer at = llSubStringIndex(s, "bork");
    while (at != -1 && n < 8) {
        ++n;
        if (at + 4 >= llStringLength(s)) return n;   // past the end, llGetSubString would wrap round (inverted range)
        s = llGetSubString(s, at + 4, -1);
        at = llSubStringIndex(s, "bork");
    }
    return n;
}

default {
    state_entry() { setup(); llListen(0, "", NULL_KEY, ""); llSetTimerEvent(25.0); }
    on_rez(integer p) { setup(); }
    changed(integer c) { if (c & CHANGED_LINK) setup(); }

    attach(key id) {
        // First time on a new owner's head: sit on top, facing forward. After that, their own adjustments stay.
        if (id != NULL_KEY && llGetAttached() == ATTACH_HEAD && fittedFor != llGetOwner()) {
            llSetPrimitiveParams([PRIM_POS_LOCAL, <0.0, 0.0, 0.08>, PRIM_ROT_LOCAL, llEuler2Rot(<0, 0, -90> * DEG_TO_RAD)]);
            fittedFor = llGetOwner();
        }
    }

    touch_start(integer n) {
        if (llGetTime() - last < 1.5) return;
        bork(3 + (integer)llFrand(6.0));
    }

    listen(integer ch, string name, key id, string msg) {
        if (llGetAgentSize(id) == ZERO_VECTOR) return;     // people only: two pups mustn't bork at each other forever
        if (llGetTime() - last < 3.0) return;
        integer n = count_borks(msg);
        if (n) bork(n);
    }

    timer() {   // now and then a happy little wag
        if (llFrand(1.0) < 0.5) return;
        integer k;
        for (k = 0; k < 4; ++k) { wag(22.0); llSleep(0.15); wag(-22.0); llSleep(0.15); }
        wag(0.0);
    }
}

"""A pup plushie for a friend, who greets friends with borks: round caramel body, big head, cream muzzle and chest,
floppy brown ears, stubby legs, a teal bandana, a little tail that wags and a tongue that shows when it borks.
-> pup.json. +x is where it looks. ~0.26 m nose to tail. An original pup (not any particular character).
Claude Opus 5.5 (Tessel), 2026-10-10."""
import json
import math
from pathlib import Path

FUR = "12a9ca4a-6ed6-b8e0-ecb3-de48f2d578f3"   # fur.png, uploaded 2026-10-10
BODY, CREAM, EAR, DARK, BANDANA, TONGUE = "#c98a4e", "#f4e4c9", "#8a5631", "#2a1e1b", "#2ea39a", "#e98a9a"
prims = []


def add(name, shape, size, pos=None, rot=None, color="#ffffff", tex="blank", **kw):
    p = {"name": name, "shape": shape, "size": [round(v, 4) for v in size], "color": color, "texture": tex, **kw}
    if pos is not None:
        p["pos"] = [round(v, 4) for v in pos]
        p["rot"] = rot or [0, 0, 0]
        p["physics_shape"] = "none"
    prims.append(p)


fur = dict(tex=FUR)
add("Bork pup", "sphere", [0.17, 0.13, 0.12], color=BODY, **fur)                               # body (root)
add("chest", "sphere", [0.07, 0.09, 0.09], [0.06, 0, -0.005], color=CREAM, **fur)
add("belly", "sphere", [0.12, 0.09, 0.05], [0.0, 0, -0.04], color=CREAM, **fur)
# head
HX, HZ = 0.115, 0.1
add("head", "sphere", [0.125, 0.135, 0.115], [HX, 0, HZ], color=BODY, **fur)
add("muzzle", "sphere", [0.06, 0.075, 0.048], [HX + 0.052, 0, HZ - 0.022], color=CREAM, **fur)
add("nose", "sphere", [0.022, 0.03, 0.018], [HX + 0.082, 0, HZ - 0.008], color=DARK, shiny="low")
add("tongue", "sphere", [0.022, 0.026, 0.008], [HX + 0.07, 0, HZ - 0.046], [0, -20, 0], color=TONGUE, alpha=0.0)
for s, side in ((1, "L"), (-1, "R")):
    add(f"eye {side}", "sphere", [0.024, 0.024, 0.028], [HX + 0.043, s * 0.03, HZ + 0.018], color=DARK, shiny="low")
    add(f"eye shine {side}", "sphere", [0.007, 0.007, 0.007], [HX + 0.054, s * 0.026, HZ + 0.027],
        color="#ffffff", fullbright=True)
    # floppy ears: long flat ovals hanging from the top sides of the head, tipped outwards
    add(f"ear {side}", "sphere", [0.04, 0.018, 0.085], [HX - 0.012, s * 0.068, HZ - 0.005], [s * 18, 8, 0],
        color=EAR, **fur)
# stubby legs with cream paws
for i, (x, y) in enumerate([(0.05, 0.04), (0.05, -0.04), (-0.05, 0.042), (-0.05, -0.042)]):
    add(f"leg {i}", "cylinder", [0.036, 0.036, 0.05], [x, y, -0.065], color=BODY, **fur)
    add(f"paw {i}", "sphere", [0.044, 0.04, 0.022], [x + 0.008, y, -0.09], color=CREAM, **fur)
# tail: a short upturned stub; the script wags it about its own z
add("tail", "sphere", [0.028, 0.028, 0.07], [-0.09, 0, 0.04], [0, -35, 0], color=BODY, **fur)
# bandana: a teal triangle under the chin and a band around the neck
add("bandana", "prism", [0.012, 0.075, 0.055], [0.095, 0, 0.015], [0, -20, 0], color=BANDANA, top_size=[0, 1])
add("collar", "cylinder", [0.1, 0.1, 0.022], [0.072, 0, 0.045], [0, 50, 0], color=BANDANA, hollow=0.8)

spec = {"name": "Bork pup", "desc": "A pup plushie made for a friend by Tessel the AI (Claude). Touch it, or say bork.",
        "defaults": {"bump": "none"}, "prims": prims}
Path(__file__).with_name("pup.json").write_text(json.dumps(spec, indent=1))
print(len(prims), "prims")

"""Fur texture and two small "bork"s for the pup plushie (for a friend). Run with local/hear-venv python.
fur.png: tileable soft short fur, neutral light grey so prim colour tints it, 256 px.
bork1.wav / bork2.wav: a small dog's bark, rounded towards "bork": rough glottal pulses ~520-600 Hz that jump up
and fall, /o/-ish formants, a lip-closed "b" start, breath noise, ~0.2 s. 44.1 kHz mono.
Claude Opus 5.5 (Tessel), 2026-10-10."""
import wave
from pathlib import Path

import numpy as np
from PIL import Image, ImageFilter

HERE = Path(__file__).parent
rng = np.random.default_rng(11)

# ---- fur: many short soft strokes, mostly one direction, wrapped so it tiles ----
S = 256
img = np.full((S, S), 0.55, np.float32)
for _ in range(5000):
    x, y = rng.random() * S, rng.random() * S
    ang = np.pi / 2 + rng.normal(0, 0.35)
    L = 4 + rng.random() * 7
    v = rng.random()
    for k in range(int(L * 2)):
        px = int(x + np.cos(ang) * k * 0.5) % S
        py = int(y + np.sin(ang) * k * 0.5) % S
        img[py, px] = img[py, px] * 0.4 + (0.35 + 0.65 * v) * 0.6
img = np.asarray(Image.fromarray((img * 255).astype(np.uint8)).filter(ImageFilter.GaussianBlur(0.7)), np.float32) / 255
img = 0.82 + 0.18 * (img - img.mean()) / (img.std() * 2.5)     # gentle: mostly the prim colour
Image.fromarray((np.clip(img, 0, 1) * 255).astype(np.uint8)).convert("RGB").save(HERE / "fur.png")
print(HERE / "fur.png")

# ---- bork ----
SR = 44100


def formant(x, f, bw):
    r = np.exp(-np.pi * bw / SR)
    a1, a2 = -2 * r * np.cos(2 * np.pi * f / SR), r * r
    y = np.zeros_like(x)
    for i in range(len(x)):
        y[i] = x[i] - a1 * y[i - 1] - a2 * y[i - 2]
    return y


def bork(f_peak, D, seed):
    r = np.random.default_rng(seed)
    t = np.arange(int(SR * D)) / SR
    u = t / D
    # pitch: jumps up fast, then falls: the bark's arc
    f0 = f_peak * (0.75 + 0.25 * np.clip(u / 0.15, 0, 1)) * (1 - 0.35 * np.clip((u - 0.2) / 0.8, 0, 1))
    f0 *= 1 + 0.04 * r.standard_normal(len(t)).cumsum() / np.sqrt(np.arange(1, len(t) + 1))   # jitter: rough voice
    ph = np.cumsum(f0) / SR
    src = (ph % 1.0) ** 4 - 0.2
    src -= src.mean()
    noise = r.standard_normal(len(t)) * 0.15                                   # breathy, a bit growly
    src = src + noise * (0.4 + 0.6 * u)
    open_ = np.clip((t - 0.012) / 0.03, 0, 1)                                  # "b": lips open
    # "o" moving towards "r": formants slide a little
    f1 = 560 - 80 * u
    f2 = 1000 + 200 * u
    vowel = formant(src, float(f1.mean()), 120) + 0.7 * formant(src, float(f2.mean()), 160) \
        + 0.3 * formant(src, 2500, 300)
    closed = formant(src, 300, 90)
    sig = closed * (1 - open_) * 0.5 + vowel * open_
    env = np.clip(t / 0.006, 0, 1) * np.exp(-np.clip(u - 0.25, 0, 1) * 5) * np.clip((D - t) / 0.03, 0, 1)
    sig *= env
    # "k": a tiny click of noise at the end
    k0 = int(SR * (D - 0.035))
    click = formant(r.standard_normal(600), 2200, 900)
    sig[k0:k0 + 600] += click / np.abs(click).max() * np.hanning(600) * 0.12 * np.abs(sig).max()
    return sig / np.abs(sig).max()


for name, fp, D, seed in (("bork1", 560, 0.2, 1), ("bork2", 620, 0.17, 2)):
    sig = bork(fp, D, seed)
    pad = np.zeros(int(SR * 0.02))
    sig = np.concatenate([sig, pad])
    with wave.open(str(HERE / f"{name}.wav"), "wb") as w:
        w.setnchannels(1); w.setsampwidth(2); w.setframerate(SR)
        w.writeframes((sig * 0.7 * 32767).astype("<i2").tobytes())
    print(HERE / f"{name}.wav")