423 lines
14 KiB
Python
Executable File
423 lines
14 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""Looping bathtub-and-duck terminal animation for Downterm demos."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import atexit
|
|
import math
|
|
import shutil
|
|
import signal
|
|
import sys
|
|
import time
|
|
from typing import Sequence
|
|
|
|
|
|
CSI = "\x1b["
|
|
RESET = f"{CSI}0m"
|
|
HIDE_CURSOR = f"{CSI}?25l"
|
|
SHOW_CURSOR = f"{CSI}?25h"
|
|
ALT_SCREEN_ON = f"{CSI}?1049h"
|
|
ALT_SCREEN_OFF = f"{CSI}?1049l"
|
|
CLEAR = f"{CSI}2J"
|
|
HOME = f"{CSI}H"
|
|
|
|
TUB = "tub"
|
|
TUB_DARK = "tub_dark"
|
|
WATER = "water"
|
|
WATER_DEEP = "water_deep"
|
|
FOAM = "foam"
|
|
BUBBLE = "bubble"
|
|
DUCK = "duck"
|
|
DUCK_LIGHT = "duck_light"
|
|
BEAK = "beak"
|
|
EYE = "eye"
|
|
LABEL = "label"
|
|
LABEL_SHADOW = "label_shadow"
|
|
|
|
RGB = {
|
|
TUB: (171, 177, 191),
|
|
TUB_DARK: (112, 118, 133),
|
|
WATER: (71, 185, 214),
|
|
WATER_DEEP: (36, 121, 161),
|
|
FOAM: (196, 242, 250),
|
|
BUBBLE: (184, 233, 245),
|
|
DUCK: (255, 208, 64),
|
|
DUCK_LIGHT: (255, 232, 132),
|
|
BEAK: (255, 154, 58),
|
|
EYE: (251, 251, 253),
|
|
LABEL: (207, 212, 222),
|
|
LABEL_SHADOW: (74, 79, 92),
|
|
}
|
|
|
|
WATER_SHADE = " .:-=+*#"
|
|
|
|
|
|
def parse_args(argv: Sequence[str]) -> argparse.Namespace:
|
|
parser = argparse.ArgumentParser(
|
|
description="Render a looping bathtub-and-duck animation."
|
|
)
|
|
parser.add_argument(
|
|
"--fps",
|
|
type=float,
|
|
default=18.0,
|
|
help="Target frames per second. Default: 18",
|
|
)
|
|
parser.add_argument(
|
|
"--speed",
|
|
type=float,
|
|
default=1.0,
|
|
help="Animation speed multiplier. Default: 1.0",
|
|
)
|
|
parser.add_argument(
|
|
"--duration",
|
|
type=float,
|
|
default=0.0,
|
|
help="Optional run duration in seconds. Default: infinite",
|
|
)
|
|
parser.add_argument(
|
|
"--label",
|
|
default="",
|
|
help="Optional centered label, e.g. --label Downterm",
|
|
)
|
|
parser.add_argument(
|
|
"--mono",
|
|
action="store_true",
|
|
help="Disable color and render as monochrome ASCII.",
|
|
)
|
|
return parser.parse_args(argv)
|
|
|
|
|
|
def terminal_size() -> tuple[int, int]:
|
|
size = shutil.get_terminal_size((90, 28))
|
|
return max(40, size.columns), max(12, size.lines)
|
|
|
|
|
|
def clamp(value: float, low: float, high: float) -> float:
|
|
return max(low, min(high, value))
|
|
|
|
|
|
def scene_size(width: int, height: int) -> tuple[int, int]:
|
|
visible_height = max(8, height - 1)
|
|
scene_width = min(max(48, width - 2), width, 110)
|
|
scene_height = min(max(16, visible_height - 1), visible_height, 24)
|
|
return scene_width, scene_height
|
|
|
|
|
|
def make_canvas(width: int, height: int) -> list[list[tuple[str, str | None]]]:
|
|
return [[(" ", None) for _ in range(width)] for _ in range(height)]
|
|
|
|
|
|
def put(canvas: list[list[tuple[str, str | None]]], x: int, y: int, char: str, color: str | None) -> None:
|
|
if 0 <= y < len(canvas) and 0 <= x < len(canvas[y]) and char:
|
|
canvas[y][x] = (char[0], color)
|
|
|
|
|
|
def draw_text(
|
|
canvas: list[list[tuple[str, str | None]]],
|
|
x: int,
|
|
y: int,
|
|
text: str,
|
|
color: str | None,
|
|
) -> None:
|
|
for index, char in enumerate(text):
|
|
if char != " ":
|
|
put(canvas, x + index, y, char, color)
|
|
|
|
|
|
def draw_sprite_text(
|
|
canvas: list[list[tuple[str, str | None]]],
|
|
x: int,
|
|
y: int,
|
|
text: str,
|
|
color: str | None,
|
|
) -> None:
|
|
for index, char in enumerate(text):
|
|
if char == " ":
|
|
continue
|
|
if char == "~":
|
|
put(canvas, x + index, y, " ", None)
|
|
continue
|
|
put(canvas, x + index, y, char, color)
|
|
|
|
|
|
def water_char(intensity: float) -> str:
|
|
index = int(clamp(intensity, 0.0, 0.9999) * len(WATER_SHADE))
|
|
return WATER_SHADE[index]
|
|
|
|
|
|
def tub_geometry(scene_width: int, scene_height: int) -> dict[str, int]:
|
|
top_y = 1
|
|
notch_width = max(28, min(scene_width - 18, int(scene_width * 0.44)))
|
|
rim_left = max(8, (scene_width - notch_width) // 2)
|
|
rim_right = min(scene_width - 9, rim_left + notch_width)
|
|
wall_left = rim_left + 1
|
|
wall_right = rim_right - 1
|
|
body_bottom = min(scene_height - 10, top_y + max(6, scene_height // 3))
|
|
water_top = top_y + 2
|
|
return {
|
|
"rim_left": rim_left,
|
|
"rim_right": rim_right,
|
|
"top_y": top_y,
|
|
"wall_left": wall_left,
|
|
"wall_right": wall_right,
|
|
"body_bottom": body_bottom,
|
|
"water_top": water_top,
|
|
}
|
|
|
|
|
|
def draw_tub(canvas: list[list[tuple[str, str | None]]], geometry: dict[str, int]) -> None:
|
|
rim_left = geometry["rim_left"]
|
|
rim_right = geometry["rim_right"]
|
|
top_y = geometry["top_y"]
|
|
wall_left = geometry["wall_left"]
|
|
wall_right = geometry["wall_right"]
|
|
body_bottom = geometry["body_bottom"]
|
|
|
|
draw_text(canvas, 2, top_y, "_" * max(0, rim_left - 2), TUB)
|
|
put(canvas, rim_left, top_y, "_", TUB)
|
|
draw_text(canvas, rim_right + 1, top_y, "_" * max(0, len(canvas[0]) - rim_right - 3), TUB)
|
|
put(canvas, rim_right, top_y, "_", TUB)
|
|
|
|
for y in range(top_y + 1, body_bottom):
|
|
put(canvas, wall_left, y, "|", TUB)
|
|
put(canvas, wall_right, y, "|", TUB)
|
|
|
|
put(canvas, wall_left, body_bottom, "\\", TUB_DARK)
|
|
draw_text(canvas, wall_left + 1, body_bottom, "_" * max(0, wall_right - wall_left - 1), TUB_DARK)
|
|
put(canvas, wall_right, body_bottom, "/", TUB_DARK)
|
|
|
|
|
|
def draw_water_fill(canvas: list[list[tuple[str, str | None]]], geometry: dict[str, int], t: float) -> None:
|
|
rim_left = geometry["wall_left"] + 1
|
|
rim_right = geometry["wall_right"] - 1
|
|
water_top = geometry["water_top"]
|
|
body_bottom = geometry["body_bottom"] - 1
|
|
|
|
depth = max(1, body_bottom - water_top)
|
|
for row in range(depth + 1):
|
|
y = water_top + row
|
|
for x in range(rim_left, rim_right + 1):
|
|
wave = math.sin((x * 0.23) + (t * 2.1) + row * 0.55)
|
|
shimmer = math.sin((x * 0.07) - (t * 1.35))
|
|
if row == 0:
|
|
char = "~" if wave > -0.22 else "-"
|
|
color = FOAM if shimmer > 0.25 else WATER
|
|
else:
|
|
density = 0.40 + row / max(1, depth)
|
|
value = 0.45 + (wave * 0.25) + (shimmer * 0.10) + density * 0.30
|
|
char = water_char(value)
|
|
color = WATER if row <= 2 else WATER_DEEP
|
|
put(canvas, x, y, char, color)
|
|
|
|
|
|
def draw_water_surface(canvas: list[list[tuple[str, str | None]]], geometry: dict[str, int], t: float) -> None:
|
|
left = geometry["wall_left"] + 1
|
|
right = geometry["wall_right"] - 1
|
|
y = geometry["water_top"]
|
|
|
|
for x in range(left, right + 1):
|
|
wave = math.sin((x * 0.23) + (t * 2.1))
|
|
shimmer = math.sin((x * 0.11) - (t * 1.15))
|
|
char = "~" if wave > -0.18 else "-"
|
|
color = FOAM if shimmer > 0.35 else WATER
|
|
put(canvas, x, y, char, color)
|
|
|
|
|
|
def draw_bubbles(canvas: list[list[tuple[str, str | None]]], geometry: dict[str, int], t: float) -> None:
|
|
rim_left = geometry["wall_left"]
|
|
water_top = geometry["water_top"]
|
|
|
|
seeds = (
|
|
(0.00, rim_left + 11, 0.9),
|
|
(0.29, rim_left + 19, 1.1),
|
|
(0.57, rim_left + 27, 0.8),
|
|
(0.82, rim_left + 35, 1.0),
|
|
)
|
|
|
|
for offset, base_x, speed in seeds:
|
|
progress = (t * 0.11 * speed + offset) % 1.0
|
|
y = water_top + 4 - int(progress * 9)
|
|
x = base_x + int(round(math.sin((t * 0.8 * speed) + offset * 8.0) * 2))
|
|
put(canvas, x, y, "o" if progress < 0.5 else ".", BUBBLE)
|
|
|
|
|
|
def draw_duck(canvas: list[list[tuple[str, str | None]]], geometry: dict[str, int], t: float) -> None:
|
|
rim_left = geometry["wall_left"]
|
|
rim_right = geometry["wall_right"]
|
|
water_top = geometry["water_top"]
|
|
|
|
span = rim_right - rim_left
|
|
bob = math.sin(t * 1.35) * 0.55
|
|
drift = math.sin(t * 0.55) * 2.0
|
|
|
|
blink_phase = int(t * 2.1) % 12
|
|
eye_char = "-" if blink_phase == 7 else "."
|
|
x = int(rim_left + span * 0.34 + drift)
|
|
y = int(water_top - 1 + bob)
|
|
|
|
rows = [
|
|
" __",
|
|
f" ___(~{eye_char})>",
|
|
" \\~<_.~) ",
|
|
" `---' ",
|
|
]
|
|
colors = [DUCK_LIGHT, DUCK, DUCK, DUCK]
|
|
|
|
for index, row in enumerate(rows):
|
|
draw_sprite_text(canvas, x, y + index, row, colors[index])
|
|
|
|
put(canvas, x + 8, y + 1, ">", BEAK)
|
|
put(canvas, x + 6, y + 1, eye_char, EYE)
|
|
|
|
if 0.74 < (t * 0.18) % 1.0 < 0.90:
|
|
splash_x = x + 9
|
|
splash_y = geometry["water_top"] - 1
|
|
for dx, dy, char in ((0, 0, "."), (2, -1, "o"), (4, 0, "."), (5, -2, "o")):
|
|
put(canvas, splash_x + dx, splash_y + dy, char, BUBBLE)
|
|
|
|
|
|
def logo_rows(text: str) -> list[str]:
|
|
if text == "commandNotch":
|
|
return [
|
|
" ██████╗ ██████╗ ███╗ ███╗███╗ ███╗ █████╗ ███╗ ██╗██████╗ ",
|
|
" ██╔════╝██╔═══██╗████╗ ████║████╗ ████║██╔══██╗████╗ ██║██╔══██╗",
|
|
" ██║ ██║ ██║██╔████╔██║██╔████╔██║███████║██╔██╗ ██║██║ ██║",
|
|
" ██║ ██║ ██║██║╚██╔╝██║██║╚██╔╝██║██╔══██║██║╚██╗██║██║ ██║",
|
|
" ╚██████╗╚██████╔╝██║ ╚═╝ ██║██║ ╚═╝ ██║██║ ██║██║ ╚████║██████╔╝",
|
|
" ╚═════╝ ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═══╝╚═════╝ ",
|
|
"",
|
|
" ███╗ ██╗ ██████╗ ████████╗ ██████╗██╗ ██╗",
|
|
" ████╗ ██║██╔═══██╗╚══██╔══╝██╔════╝██║ ██║",
|
|
" ██╔██╗ ██║██║ ██║ ██║ ██║ ███████║",
|
|
" ██║╚██╗██║██║ ██║ ██║ ██║ ██╔══██║",
|
|
" ██║ ╚████║╚██████╔╝ ██║ ╚██████╗██║ ██║",
|
|
" ╚═╝ ╚═══╝ ╚═════╝ ╚═╝ ╚═════╝╚═╝ ╚═╝",
|
|
]
|
|
|
|
return [text]
|
|
|
|
|
|
def draw_label(canvas: list[list[tuple[str, str | None]]], label: str) -> None:
|
|
logo = logo_rows(label or "commandNotch")
|
|
start_y = len(canvas) - len(logo) - 1
|
|
|
|
for index, row in enumerate(logo):
|
|
start_x = max(0, (len(canvas[0]) - len(row)) // 2)
|
|
draw_text(canvas, start_x, start_y + index, row, LABEL)
|
|
|
|
|
|
def scene_canvas(scene_width: int, scene_height: int, t: float, label: str) -> list[list[tuple[str, str | None]]]:
|
|
canvas = make_canvas(scene_width, scene_height)
|
|
geometry = tub_geometry(scene_width, scene_height)
|
|
draw_tub(canvas, geometry)
|
|
draw_water_fill(canvas, geometry, t)
|
|
draw_water_surface(canvas, geometry, t)
|
|
draw_duck(canvas, geometry, t)
|
|
draw_bubbles(canvas, geometry, t)
|
|
draw_label(canvas, label)
|
|
return canvas
|
|
|
|
|
|
def ansi_rgb(color_name: str | None) -> str:
|
|
if color_name is None:
|
|
return RESET
|
|
red, green, blue = RGB[color_name]
|
|
return f"{CSI}38;2;{red};{green};{blue}m"
|
|
|
|
|
|
def render_scene_line(cells: list[tuple[str, str | None]], mono: bool) -> str:
|
|
if mono:
|
|
return "".join(char for char, _ in cells)
|
|
|
|
chunks: list[str] = []
|
|
current_color: str | None = None
|
|
for char, color in cells:
|
|
if color != current_color:
|
|
chunks.append(ansi_rgb(color))
|
|
current_color = color
|
|
chunks.append(char)
|
|
chunks.append(RESET)
|
|
return "".join(chunks)
|
|
|
|
|
|
def render_frame(width: int, height: int, t: float, label: str, mono: bool) -> str:
|
|
visible_height = max(8, height - 1)
|
|
scene_width, scene_height = scene_size(width, height)
|
|
scene = scene_canvas(scene_width, scene_height, t, label)
|
|
top_padding = max(0, (visible_height - scene_height) // 2)
|
|
left_padding = max(0, (width - scene_width) // 2)
|
|
|
|
pieces: list[str] = [HOME]
|
|
blank_line = " " * width
|
|
|
|
for row in range(visible_height):
|
|
if top_padding <= row < top_padding + scene_height:
|
|
scene_row = scene[row - top_padding]
|
|
rendered = render_scene_line(scene_row, mono)
|
|
right_padding = max(0, width - left_padding - scene_width)
|
|
line = (" " * left_padding) + rendered + (" " * right_padding)
|
|
else:
|
|
line = blank_line
|
|
|
|
pieces.append(line)
|
|
if row != visible_height - 1:
|
|
pieces.append("\n")
|
|
|
|
return "".join(pieces)
|
|
|
|
|
|
def restore_terminal() -> None:
|
|
sys.stdout.write(f"{RESET}{SHOW_CURSOR}{ALT_SCREEN_OFF}")
|
|
sys.stdout.flush()
|
|
|
|
|
|
def install_cleanup() -> None:
|
|
def handle_signal(signum, _frame) -> None:
|
|
restore_terminal()
|
|
raise SystemExit(128 + signum)
|
|
|
|
atexit.register(restore_terminal)
|
|
signal.signal(signal.SIGINT, handle_signal)
|
|
signal.signal(signal.SIGTERM, handle_signal)
|
|
|
|
|
|
def main(argv: Sequence[str]) -> int:
|
|
args = parse_args(argv)
|
|
if args.fps <= 0:
|
|
raise SystemExit("--fps must be greater than 0")
|
|
if args.speed <= 0:
|
|
raise SystemExit("--speed must be greater than 0")
|
|
|
|
install_cleanup()
|
|
|
|
sys.stdout.write(f"{ALT_SCREEN_ON}{HIDE_CURSOR}{CLEAR}")
|
|
sys.stdout.flush()
|
|
|
|
frame_interval = 1.0 / args.fps
|
|
start = time.perf_counter()
|
|
frame_index = 0
|
|
|
|
while True:
|
|
now = time.perf_counter()
|
|
elapsed = now - start
|
|
if args.duration > 0 and elapsed >= args.duration:
|
|
break
|
|
|
|
width, height = terminal_size()
|
|
t = elapsed * args.speed
|
|
sys.stdout.write(render_frame(width, height, t, args.label, args.mono))
|
|
sys.stdout.flush()
|
|
|
|
frame_index += 1
|
|
target = start + (frame_index * frame_interval)
|
|
sleep_for = target - time.perf_counter()
|
|
if sleep_for > 0:
|
|
time.sleep(sleep_for)
|
|
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main(sys.argv[1:]))
|