primocode 10.16.0 → 10.17.1

package/editor/helpers/motion/templates/etiqueta_preco.py

@@ -0,0 +1,461 @@
+"""etiqueta_preco: a price tag that pops in with a spring and settles slightly tilted, with the cents raised
+like a shop price, an optional old price crossed out above it and a shine that sweeps the tag once
+(SPEC Contract 12). Two looks: "etiqueta" (hang tag with a hole) and "selo" (round scalloped seal).
+
+`_add_shine` is a soft diagonal light band on an image and `_transform` scales and rotates the small cached
+tag sprite in one resampling step (a rotated group would redraw and resample its layer on every frame).
+"""
+
+from __future__ import annotations
+
+import json
+import math
+from functools import lru_cache
+
+import numpy as np
+from PIL import Image
+
+from motion import engine as E
+
+TEMPLATE = {
+    "id": "etiqueta_preco",
+    "label_pt": "Etiqueta de preço",
+    "description_pt": "Uma etiqueta de preço na cor do vídeo que entra com um pulo e fica levemente inclinada, "
+                      "com os centavos pequenos no alto. Opcional: o preço antigo riscado em cima e uma frase "
+                      "curta embaixo do preço.",
+    "use_when_pt": "Quando a fala diz o preço da oferta (\"por apenas 37 reais\") ou compara com o preço antigo. "
+                   "O preço antigo precisa ser o de verdade.",
+    "category": "oferta",
+    "version": 1,
+    "params": {
+        "price": {"type": "number", "default": 37, "min": 0, "max": 1e9,
+                  "label_pt": "Preço (use ponto para os centavos: 37.90)"},
+        "old_price": {"type": "number", "default": None, "nullable": True, "min": 0, "max": 1e9,
+                      "label_pt": "Preço antigo, riscado em cima (vazio: sem preço antigo)"},
+        "prefix": {"type": "text", "default": "R$", "max_len": 4, "label_pt": "Moeda antes do preço, ex.: R$ ou US$"},
+        "decimals": {"type": "integer", "default": None, "nullable": True, "min": 0, "max": 2,
+                     "label_pt": "Casas decimais (vazio: centavos só quando o preço tem centavos)"},
+        "label": {"type": "text", "default": "por apenas", "max_len": 20,
+                  "label_pt": "Texto pequeno em cima do preço (vazio: sem texto)"},
+        "note": {"type": "text", "default": "", "max_len": 26,
+                 "label_pt": "Frase curta embaixo do preço, ex.: \"à vista no PIX\" ou \"12x de R$ 3,70\""},
+        "old_label": {"type": "text", "default": "de", "max_len": 8, "label_pt": "Palavra antes do preço antigo"},
+        "mode": {"type": "choice", "choices": ["etiqueta", "selo"], "default": "etiqueta",
+                 "label_pt": "etiqueta (com furinho) ou selo (redondo com borda ondulada)"},
+        "tilt": {"type": "number", "default": -4, "min": -12, "max": 12,
+                 "label_pt": "Inclinação final em graus (negativo sobe para a direita)"},
+        "shine": {"type": "bool", "default": True, "label_pt": "Brilho que passa pela etiqueta uma vez"},
+        "tag_delay": {"type": "number", "default": 0.62, "min": 0.45, "max": 5,
+                      "label_pt": "Com preço antigo: segundos entre o preço antigo aparecer e a etiqueta pular "
+                                  "(para bater com a fala \"de 97... por 37\")"},
+    },
+    "default_duration": 3.0,
+    "default_region": "baixo",
+    "sfx": [{"at": 0.0, "name": "cash"}],
+    "example": {"price": 37.9, "old_price": 97, "note": "à vista no PIX"},
+}
+
+SPRING = (0.5, 2.4)                        # damping, frequency of the pop (about 16% overshoot)
+SPRING_T = E.spring_settle(*SPRING)        # seconds until it rests
+STRIKE_AT, STRIKE_DUR = 0.30, 0.28         # the old price gets crossed
+SHINE_AT, SHINE_DUR = 0.42, 0.62           # after the pop
+POP_SWING = -9.0                           # extra degrees at the start of the pop
+
+
+def _tag_start(p: dict) -> float:
+    """The tag pops at the item start, or `tag_delay` after the old price (which appears at the start)."""
+    return p["tag_delay"] if p["old_price"] is not None else 0.0
+
+
+def _decimals(v: float, fixed) -> int:
+    if fixed is not None:
+        return int(fixed)
+    return 2 if abs(v - round(v)) > 1e-9 else 0
+
+
+def _price_parts(p: dict) -> tuple[str, str, str]:
+    dec = _decimals(p["price"], p["decimals"])
+    s = E.format_number(p["price"], dec)
+    whole, _, cents = s.partition(",")
+    return p["prefix"].strip(), whole, ("," + cents) if cents else ""
+
+
+# ------------------------------------------------------------------ layout (once per item)
+
+@lru_cache(maxsize=64)
+def _layout(params_json: str, box: E.Box) -> dict:
+    p = json.loads(params_json)
+    prefix, whole, cents = _price_parts(p)
+    label = p["label"].strip()
+    note = p["note"].strip()
+    selo = p["mode"] == "selo"
+    theme = box.theme
+
+    def price_row(P: float) -> dict:
+        pre_s, cen_s = P * 0.30, P * 0.42
+        pre_w = E.measure(prefix, "sans_black", pre_s).width if prefix else 0.0
+        gap_p = P * 0.08 if prefix else 0.0
+        num_w = E.measure(whole, "sans_black", P).width
+        gap_c = P * 0.03 if cents else 0.0
+        cen_w = E.measure(cents, "sans_black", cen_s).width if cents else 0.0
+        return {"P": P, "pre_s": pre_s, "cen_s": cen_s, "pre_w": pre_w, "gap_p": gap_p, "num_w": num_w,
+                "gap_c": gap_c, "cen_w": cen_w, "w": pre_w + gap_p + num_w + gap_c + cen_w,
+                "cap": E.measure("0", "sans_black", P).cap}
+
+    # old price pill (above the tag)
+    old = None
+    if p["old_price"] is not None:
+        dec_o = _decimals(p["old_price"], p["decimals"])
+        o_label = p["old_label"].strip()
+        o_price = (prefix + " " if prefix else "") + E.format_number(p["old_price"], dec_o)
+        o_size = E.fit_text(f"{o_label} {o_price}", "text_bold", box.w - 80.0, 44.0, 28.0)
+        lab_w = E.measure(o_label, "text_bold", o_size).width if o_label else 0.0
+        gap = o_size * 0.28 if o_label else 0.0
+        pr_w = E.measure(o_price, "text_bold", o_size).width
+        cap = E.measure("H", "text_bold", o_size).cap
+        pad_x, pad_y = 30.0, 22.0
+        old = {"size": o_size, "label": o_label, "price": o_price, "lab_w": lab_w, "gap": gap, "pr_w": pr_w,
+               "cap": cap, "w": lab_w + gap + pr_w + 2 * pad_x, "h": cap + 2 * pad_y, "pad_x": pad_x}
+    pill_block = (old["h"] + 30.0) if old else 0.0
+
+    lab_size, note_size = 32.0, 34.0
+    lab_cap = E.measure("H", "text_bold", lab_size).cap if label else 0.0
+    note_cap = E.measure("H", "text_semibold", note_size).cap if note else 0.0
+    lab_w = E.measure(label.upper(), "text_bold", lab_size, tracking=2.5).width if label else 0.0
+    note_w = E.measure(note, "text_semibold", note_size).width if note else 0.0
+    gap1 = 20.0 if label else 0.0
+    gap2 = 24.0 if note else 0.0
+
+    avail_h = box.h - pill_block - 12.0
+    if selo:
+        # round seal: the content sits in the middle 70% of the circle
+        P = 150.0
+        row = price_row(P)
+        for _ in range(3):
+            stack_h = lab_cap + gap1 + row["cap"] + gap2 + note_cap
+            need = max(row["w"] / 1.28, lab_w / 1.2, note_w / 1.2)     # inside the inner ring
+            R = max(need, stack_h / 1.25 + 10.0, 150.0)
+            R_max = min(box.w * 0.5 - 30.0, avail_h / 2.0)
+            if R <= R_max:
+                break
+            k = R_max / R
+            P = max(60.0, P * k)
+            row = price_row(P)
+            if label:
+                lab_size = max(24.0, lab_size * k)
+            if note:
+                note_size = max(24.0, note_size * k)
+            lab_cap = E.measure("H", "text_bold", lab_size).cap if label else 0.0
+            note_cap = E.measure("H", "text_semibold", note_size).cap if note else 0.0
+            lab_w = E.measure(label.upper(), "text_bold", lab_size, tracking=2.5).width if label else 0.0
+            note_w = E.measure(note, "text_semibold", note_size).width if note else 0.0
+        R = min(R, R_max)
+        tag_w = tag_h = 2 * R
+        stack_h = lab_cap + gap1 + row["cap"] + gap2 + note_cap
+        block_h = pill_block + tag_h
+        top = (box.h - block_h) / 2.0
+        tag_x = (box.w - tag_w) / 2.0
+        tag_y = top + pill_block
+        content_cx = box.w / 2.0
+        content_top = tag_y + R - stack_h / 2.0
+        shape = {"kind": "selo", "cx": content_cx, "cy": tag_y + R, "R": R}
+    else:
+        pad_t, pad_b = (34.0, 36.0) if (label or note) else (44.0, 44.0)
+        pad_l, pad_r = 36.0, 52.0
+        P = 180.0
+        row = price_row(P)
+        # fit the tilted tag (its rotated bounding box) in the box
+        ca, sa = math.cos(math.radians(abs(p["tilt"]))), math.sin(math.radians(abs(p["tilt"])))
+        for _ in range(6):
+            tag_h = pad_t + lab_cap + gap1 + row["cap"] + gap2 + note_cap + pad_b
+            point_w = tag_h * 0.30
+            inner = max(row["w"], lab_w, note_w)
+            tag_w = max(point_w + pad_l + inner + pad_r, 420.0)
+            rot_w, rot_h = tag_w * ca + tag_h * sa, tag_w * sa + tag_h * ca
+            k = min((box.w - 24.0) / rot_w, avail_h / rot_h, 1.0)
+            if k >= 0.995:
+                break
+            k = max(k, 0.5) * 0.99
+            P = max(60.0, P * k)
+            row = price_row(P)
+            if label:
+                lab_size = max(24.0, lab_size * k)
+                lab_cap = E.measure("H", "text_bold", lab_size).cap
+                lab_w = E.measure(label.upper(), "text_bold", lab_size, tracking=2.5).width
+            if note:
+                note_size = max(24.0, note_size * k)
+                note_cap = E.measure("H", "text_semibold", note_size).cap
+                note_w = E.measure(note, "text_semibold", note_size).width
+        inner = tag_w - point_w - pad_l - pad_r
+        rot_h = tag_w * sa + tag_h * ca
+        block_h = pill_block + rot_h
+        top = (box.h - block_h) / 2.0
+        tag_x = (box.w - tag_w) / 2.0
+        tag_y = top + pill_block + rot_h / 2.0 - tag_h / 2.0
+        body_x = tag_x + point_w
+        content_cx = body_x + pad_l + inner / 2.0
+        content_top = tag_y + pad_t
+        r = 16.0
+        pts = [(body_x, tag_y), (tag_x + tag_w, tag_y), (tag_x + tag_w, tag_y + tag_h), (body_x, tag_y + tag_h),
+               (tag_x, tag_y + tag_h / 2.0)]
+        shape = {"kind": "etiqueta", "pts": pts, "radius": r,
+                 "hole": (tag_x + point_w * 0.62, tag_y + tag_h / 2.0), "hole_r": max(9.0, tag_h * 0.055)}
+
+    y = content_top
+    lab_base = y + lab_cap
+    price_top = lab_base + gap1 if label else y
+    price_base = price_top + row["cap"]
+    note_base = price_base + gap2 + note_cap
+    tag_cx, tag_cy = tag_x + tag_w / 2.0, tag_y + tag_h / 2.0
+    out = {
+        "prefix": prefix, "whole": whole, "cents": cents, "label": label.upper(), "note": note,
+        "lab_size": lab_size, "note_size": note_size, "lab_base": lab_base, "note_base": note_base,
+        "row": row, "price_x": content_cx - row["w"] / 2.0, "price_top": price_top, "price_base": price_base,
+        "content_cx": content_cx, "tag": (tag_x, tag_y, tag_w, tag_h), "pivot": (tag_cx, tag_cy),
+        "shape": shape, "old": old, "on_accent": theme.on_accent,
+    }
+    if old:
+        ox = tag_cx - old["w"] / 2.0 if selo else min(max(tag_x + 10.0, tag_cx - old["w"] / 2.0),
+                                                      box.w - old["w"])
+        oy = top
+        out["old_box"] = (ox, oy, old["w"], old["h"])
+        tx = ox + old["pad_x"]
+        out["old_lab_x"] = tx
+        out["old_pr_x"] = tx + old["lab_w"] + old["gap"]
+        out["old_base"] = oy + (old["h"] + old["cap"]) / 2.0
+    return out
+
+
+# ------------------------------------------------------------------ drawing
+#
+# The tag is drawn flat once, on a small canvas of its own (vector, scale 1, no tilt). Each frame of the pop
+# scales and rotates that sprite in one resampling step and casts its shadow; the resting result (scale 1,
+# final tilt, shadow) is cached, so the shine frames only add the light band. The engine's rotated group
+# resamples its whole layer instead (about 40 ms a frame for this item).
+
+TAG_SHADOW = E.Shadow(blur=26.0, dy=16.0, opacity=0.40)
+
+
+def _draw_shape(cv: E.Canvas, L: dict) -> None:
+    sh = L["shape"]
+    ink = L["on_accent"]
+    if sh["kind"] == "etiqueta":
+        cv.fill_mask(cv.polygon_mask(sh["pts"], radius=sh["radius"]), "accent")
+        # a stitched line inside the edge
+        tx, ty, tw, th = L["tag"]
+        inset = 14.0
+        body_x = sh["pts"][0][0]
+        ip = [(body_x + inset * 0.45, ty + inset), (tx + tw - inset, ty + inset), (tx + tw - inset, ty + th - inset),
+              (body_x + inset * 0.45, ty + th - inset), (tx + inset * 2.1, ty + th / 2.0)]
+        ip.append(ip[0])
+        total = E.path_length(ip)
+        dash, gap = 16.0, 11.0
+        k = 0.0
+        while k < total - 2.0:
+            cv.polyline(E.trim_points(ip, k / total, min(total, k + dash) / total), width=3.0,
+                        color=(ink[0], ink[1], ink[2], 60))
+            k += dash + gap
+        hx, hy = sh["hole"]
+        cv.circle(hx, hy, sh["hole_r"] + 7.0, fill=(ink[0], ink[1], ink[2], 40))
+    else:
+        cx, cy, R = sh["cx"], sh["cy"], sh["R"]
+        bumps = 20
+        parts = [cv.circle_mask(cx, cy, R * 0.90)]
+        for i in range(bumps):
+            a = 2 * math.pi * i / bumps
+            parts.append(cv.circle_mask(cx + math.cos(a) * R * 0.86, cy + math.sin(a) * R * 0.86, R * 0.14))
+        cv.fill_mask(E.union_masks(parts), "accent")
+        cv.ring(cx, cy, R * 0.74, 3.0, color=(ink[0], ink[1], ink[2], 60))
+
+
+def _draw_text(cv: E.Canvas, L: dict) -> None:
+    row = L["row"]
+    ink = "on_accent"
+    if L["label"]:
+        cv.text(L["content_cx"], L["lab_base"], L["label"], "text_bold", L["lab_size"], color=ink, opacity=0.78,
+                anchor="ms", tracking=2.5)
+    x = L["price_x"]
+    top = L["price_top"]
+    if L["prefix"]:
+        cv.text(x, top, L["prefix"], "sans_black", row["pre_s"], color=ink, anchor="lt")
+        x += row["pre_w"] + row["gap_p"]
+    cv.text(x, L["price_base"], L["whole"], "sans_black", row["P"], color=ink)
+    x += row["num_w"] + row["gap_c"]
+    if L["cents"]:
+        cv.text(x, top, L["cents"], "sans_black", row["cen_s"], color=ink, anchor="lt")
+    if L["note"]:
+        cv.text(L["content_cx"], L["note_base"], L["note"], "text_semibold", L["note_size"], color=ink,
+                opacity=0.86, anchor="ms")
+
+
+@lru_cache(maxsize=8)
+def _flat_sprite(params_json: str, box: E.Box) -> tuple[Image.Image, int, int]:
+    """The flat tag (no tilt, no shadow, scale 1): (RGBA image, x, y) in render px of the output canvas."""
+    L = _layout(params_json, box)
+    tx, ty, tw, th = L["tag"]
+    m = 6.0
+    sub = E.Canvas(E.with_box(box, x=box.x + tx - m, y=box.y + ty - m, w=tw + 2 * m, h=th + 2 * m, bleed=0.0))
+    with sub.group(dx=-(tx - m), dy=-(ty - m)):          # main-box coordinates inside the sprite
+        _draw_shape(sub, L)
+        _draw_text(sub, L)
+        if L["shape"]["kind"] == "etiqueta":
+            hx, hy = L["shape"]["hole"]
+            sub.erase_circle(hx, hy, L["shape"]["hole_r"])
+    return sub.image, sub.origin_x, sub.origin_y
+
+
+def _transform(sprite: Image.Image, ax: int, ay: int, pivot: tuple[float, float], scale: float, angle: float,
+               resample) -> tuple[Image.Image, int, int]:
+    """Scale and rotate (clockwise degrees) a sprite around a render-px point of the output canvas.
+    Returns the new image and its render-px position."""
+    px, py = pivot
+    if scale < 0.85:          # shrink with a proper filter first (no aliasing on the small first frames)
+        w = max(1, int(round(sprite.width * scale)))
+        h = max(1, int(round(sprite.height * scale)))
+        sx, sy = w / sprite.width, h / sprite.height
+        sprite = sprite.convert("RGBa").resize((w, h), Image.LANCZOS).convert("RGBA")
+        ax, ay = px + (ax - px) * sx, py + (ay - py) * sy
+        scale = scale / ((sx + sy) / 2.0)
+    th = math.radians(angle)
+    cs, sn = math.cos(th), math.sin(th)
+    corners = [(ax, ay), (ax + sprite.width, ay), (ax, ay + sprite.height), (ax + sprite.width, ay + sprite.height)]
+    rx = [px + scale * ((x - px) * cs - (y - py) * sn) for x, y in corners]
+    ry = [py + scale * ((x - px) * sn + (y - py) * cs) for x, y in corners]
+    bx0, by0 = int(math.floor(min(rx))) - 1, int(math.floor(min(ry))) - 1
+    bx1, by1 = int(math.ceil(max(rx))) + 1, int(math.ceil(max(ry))) + 1
+    if abs(angle) < 1e-6 and abs(scale - 1.0) < 1e-9 and float(ax).is_integer() and float(ay).is_integer():
+        return sprite, int(ax), int(ay)
+    # output pixel (X, Y) -> sprite pixel: undo the rotation and the scale around the pivot
+    k = 1.0 / scale
+    coeffs = (cs * k, sn * k, px + (cs * (bx0 - px) + sn * (by0 - py)) * k - ax,
+              -sn * k, cs * k, py + (-sn * (bx0 - px) + cs * (by0 - py)) * k - ay)
+    out = sprite.convert("RGBa").transform((bx1 - bx0, by1 - by0), Image.AFFINE, coeffs, resample=resample)
+    return out.convert("RGBA"), bx0, by0
+
+
+def _shadow(cv_like: E.Canvas, img: Image.Image, x: int, y: int):
+    """Blurred alpha of a placed image, moved down (a Mask in the canvas' render px)."""
+    alpha = np.asarray(img.getchannel("A"), np.float32) / 255.0
+    sh = E.blur_mask(E.Mask(alpha, x - cv_like.origin_x, y - cv_like.origin_y), cv_like.len(TAG_SHADOW.blur),
+                     cv_like.W, cv_like.H)
+    sh.y += int(round(cv_like.len(TAG_SHADOW.dy)))
+    return sh
+
+
+@lru_cache(maxsize=8)
+def _resting(params_json: str, box: E.Box):
+    """The tag at rest (scale 1, final tilt, high quality resampling) and its shadow mask."""
+    L = _layout(params_json, box)
+    p = json.loads(params_json)
+    sprite, ax, ay = _flat_sprite(params_json, box)
+    pv = ((box.x + L["pivot"][0]) * box.scale, (box.y + L["pivot"][1]) * box.scale)
+    img, x, y = _transform(sprite, ax, ay, pv, 1.0, p["tilt"], Image.BICUBIC)
+    return img, x, y, _shadow(E.Canvas(box), img, x, y)
+
+
+def _add_shine(img: Image.Image, progress: float, width_px: float, opacity: float, accent) -> Image.Image:
+    """A soft light band tilted 20 degrees crossing the tag, straight alpha. It lights the accent surface only:
+    the printed text and the hole stay as they are."""
+    arr = np.asarray(img)
+    h, w = arr.shape[:2]
+    xs = np.arange(w, dtype=np.float32)[None, :] + 0.5
+    ys = np.arange(h, dtype=np.float32)[:, None] + 0.5
+    half = max(1.0, width_px / 2.0)
+    u = xs + (ys - h / 2.0) * math.tan(math.radians(20))
+    c = -half * 2 + (w + half * 4) * E.in_out_sine(progress)
+    band = np.clip(1.0 - np.abs(u - c) / half, 0.0, 1.0) ** 1.5
+    out = arr.astype(np.float32)
+    a_dst = out[..., 3] / 255.0
+    dist = np.abs(out[..., :3] - np.array(accent[:3], np.float32)).max(axis=2)
+    surface = np.clip(1.0 - dist / 90.0, 0.0, 1.0)     # 1 on the tag color, 0 on the text
+    a_src = band * opacity * a_dst * surface
+    a_out = a_src + a_dst * (1.0 - a_src)
+    safe = np.where(a_out > 0, a_out, 1.0)
+    for c_i in range(3):
+        out[..., c_i] = (255.0 * a_src + out[..., c_i] * a_dst * (1.0 - a_src)) / safe
+    out[..., 3] = a_out * 255.0
+    return Image.fromarray(np.clip(out + 0.5, 0, 255).astype(np.uint8), "RGBA")
+
+
+def render(frame_index: int, fps: int, params: dict, box: E.Box) -> E.Canvas:
+    cv = E.Canvas(box)
+    t = frame_index / fps
+    key = json.dumps(params, sort_keys=True)
+    L = _layout(key, box)
+    t_in = t + 1.0 / fps
+    d = 0.0
+    T = _tag_start(params)
+
+    # the tag: spring pop and swing into its tilt
+    local = t_in - T
+    if local > 0:
+        sp = 1.0 if local >= SPRING_T else E.spring(local, *SPRING)
+        alpha = E.clamp01(local / 0.08)
+        scale = 0.5 + 0.5 * sp                      # peaks near 1.08: a small bounce
+        angle = params["tilt"] + POP_SWING * (1.0 - sp)
+        if sp == 1.0:
+            img, x, y, shadow = _resting(key, box)
+        else:
+            sprite, ax, ay = _flat_sprite(key, box)
+            pv = ((box.x + L["pivot"][0]) * box.scale, (box.y + L["pivot"][1]) * box.scale)
+            img, x, y = _transform(sprite, ax, ay, pv, scale, angle, Image.BILINEAR)
+            shadow = _shadow(cv, img, x, y)
+        shine_p = E.progress(t, T + SHINE_AT, SHINE_DUR)
+        if params["shine"] and 0.0 < shine_p < 1.0:
+            img = _add_shine(img, shine_p, cv.len(L["tag"][3] * 0.55), 0.42, box.theme.accent)
+        cv.fill_mask(shadow, (0, 0, 0), TAG_SHADOW.opacity * alpha)
+        if L["shape"]["kind"] == "etiqueta":         # the hole shows the video, not the shadow
+            hx, hy = L["shape"]["hole"]
+            pvx, pvy = L["pivot"]
+            ca, sa = math.cos(math.radians(angle)), math.sin(math.radians(angle))
+            dx, dy = hx - pvx, hy - pvy
+            cv.erase_circle(pvx + scale * (dx * ca - dy * sa), pvy + scale * (dx * sa + dy * ca),
+                            L["shape"]["hole_r"] * scale)
+        s = box.scale
+        cv.paste_image(img, x / s - box.x, y / s - box.y, opacity=alpha)
+
+    # the old price: slides in, gets crossed, then steps back a little
+    old = L["old"]
+    if old:
+        q = t_in - d
+        if q > 0:
+            a = E.eased(q, 0.0, 0.18, "out_quad") * (1.0 - 0.22 * E.eased(t, T, 0.3))
+            s = 0.9 + 0.1 * E.out_back(E.progress(q, 0.0, 0.4), 1.6)
+            ox, oy, ow, oh = L["old_box"]
+            with cv.group(opacity=a, scale=s, dy=18.0 * (1.0 - E.eased(q, 0.0, 0.35)),
+                          pivot=(ox + ow / 2.0, oy + oh / 2.0)):
+                cv.card(ox, oy, ow, oh, radius=oh / 2.0)
+                base = L["old_base"]
+                if old["label"]:
+                    cv.text(L["old_lab_x"], base, old["label"], "text_bold", old["size"], color="muted")
+                cv.text(L["old_pr_x"], base, old["price"], "text_bold", old["size"], color="text")
+                k = E.eased(t, d + STRIKE_AT, STRIKE_DUR, "in_out_cubic")
+                if k > 0:
+                    x0 = L["old_pr_x"] - 8.0
+                    x1 = L["old_pr_x"] + old["pr_w"] + 8.0
+                    mid = base - old["cap"] * 0.42
+                    cv.line(x0, mid + 7.0, x1, mid - 7.0, width=7.0, color="danger", progress=k)
+    return cv
+
+
+def sfx(params: dict, fps: int, frames: int) -> list[dict]:
+    d = 0.0
+    cues = []
+    if params["old_price"] is not None:
+        cues.append({"at": d, "name": "pop", "volume": 0.9, "why": "preço antigo"})
+        cues.append({"at": d + STRIKE_AT, "name": "tick", "why": "risco no preço antigo"})
+    cues.append({"at": _tag_start(params), "name": "cash", "why": "preço novo"})
+    return [{"frame": E.frame_of(c.pop("at"), fps), **c} for c in cues]
+
+
+def suggested_duration(params: dict) -> float:
+    """The pop, the shine and about 1.6 s to read the price."""
+    return round(max(TEMPLATE["default_duration"], settle(params, 30) + 1.6), 2)
+
+
+def settle(params: dict, fps: int) -> float:
+    T = _tag_start(params)
+    end = T + max(SPRING_T, SHINE_AT + SHINE_DUR)
+    if params["old_price"] is not None:
+        end = max(end, STRIKE_AT + STRIKE_DUR, T + 0.3)
+    return end + 0.05