A drawing app built for agent/human collaboration
Rust
import json
import math
import sys
BODY = (512.0, 640.0)
GROUND = 820.0
DEPTH = 12.0
LAYERS = ["shadow", "far", "colour", "shade", "rim", "lines"]
IDLE = [
(0, 2, {"bob": 0, "sx": 1.0, "sy": 1.0, "tilt": 0, "sprout": 0, "eye": 9, "near": (0, 0), "far": (0, 0)}),
(2, 1, {"bob": 7, "sx": 1.04, "sy": 0.95, "tilt": 0, "sprout": -8, "eye": 5, "near": (0, 0), "far": (0, 0)}),
]
WALK = [
(3, 2, {"bob": 8, "sx": 1.03, "sy": 0.97, "tilt": 2, "sprout": -3, "eye": 9, "near": (14, 0), "far": (-14, 0)}),
(5, 2, {"bob": -6, "sx": 0.98, "sy": 1.03, "tilt": 5, "sprout": -8, "eye": 9, "near": (0, 0), "far": (4, 26)}),
(7, 2, {"bob": 8, "sx": 1.03, "sy": 0.97, "tilt": -2, "sprout": 3, "eye": 9, "near": (-14, 0), "far": (14, 0)}),
(9, 2, {"bob": -6, "sx": 0.98, "sy": 1.03, "tilt": -5, "sprout": 8, "eye": 9, "near": (4, 26), "far": (0, 0)}),
]
REORDERED = {7, 9}
def body(pose):
tilt = math.radians(pose["tilt"])
ct, st = math.cos(tilt), math.sin(tilt)
def world(u, v):
x, y = u * pose["sx"], 100 + (v - 100) * pose["sy"]
return (BODY[0] + x * ct - y * st, BODY[1] + pose["bob"] + x * st + y * ct)
return world
def oval(world, cx, cy, rx, ry, a0=0.0, a1=360.0, steps=40):
return [
world(cx + rx * math.cos(math.radians(a0 + (a1 - a0) * i / steps)), cy + ry * math.sin(math.radians(a0 + (a1 - a0) * i / steps)))
for i in range(steps + 1)
]
def rim_y(u):
return -10 + 14 * (1 - (u / 150) ** 2)
def path(points):
return "M" + " L".join(f"{x:.1f} {y:.1f}" for x, y in points)
def poly(points):
return [[round(x, 1), round(y, 1)] for x, y in points]
def ink(frame, points, size, taper=(0, 0), pressure=(0.8, 1, 1, 0.85), layer="lines", color="ink", brush="ink", part="body"):
return {
"op": "stroke",
"layer": layer,
"frame": frame,
"brush": brush,
"color": color,
"size": size,
"path": path(points),
"pressure": list(pressure),
"taper": list(taper),
"part": part,
}
def leg(world, angle, placed, depth=0.0):
step, lift = placed
def belly(a):
r = math.radians(a)
return world(130 * math.cos(r), -6.5 + 106 * math.sin(r))
hip = belly(angle)
planted = BODY[0] + 130 * math.cos(math.radians(angle))
f = (planted + step, GROUND - 16 - depth - lift)
dx, dy = f[0] - hip[0], f[1] - hip[1]
n = math.hypot(dx, dy) or 1.0
d = (dx / n, dy / n)
side = (-d[1], d[0])
w = 19
right = (f[0] - side[0] * w, f[1] - side[1] * w)
left = (f[0] + side[0] * w, f[1] + side[1] * w)
p1, p2 = belly(angle - 11), belly(angle + 11)
down = [(p1[0] + (right[0] - p1[0]) * t / 6, p1[1] + (right[1] - p1[1]) * t / 6) for t in range(6)]
turn = [
(f[0] + w * (-side[0] * math.cos(a) + d[0] * math.sin(a)), f[1] + w * (-side[1] * math.cos(a) + d[1] * math.sin(a)))
for a in (math.pi * i / 10 for i in range(11))
]
up = [(left[0] + (p2[0] - left[0]) * t / 6, left[1] + (p2[1] - left[1]) * t / 6) for t in range(1, 7)]
return down + turn + up, ((hip[0] + f[0]) / 2, (hip[1] + f[1]) / 2)
def sprout(world, sway):
a = math.radians(sway)
base = (0.0, -180.0)
def turned(u, v):
x, y = u - base[0], v - base[1]
return world(base[0] + x * math.cos(a) - y * math.sin(a), base[1] + x * math.sin(a) + y * math.cos(a))
stem = [turned(10 * math.sin(t * 2.4), -180 - 78 * t) for t in (i / 14 for i in range(15))]
tip = (10 * math.sin(2.4), -258.0)
leaf = [
turned(tip[0] - 64 * t, tip[1] - 14 * t + s * 22 * math.sin(math.pi * t) ** 0.8)
for s, ts in ((-1, range(17)), (1, range(16, -1, -1)))
for t in (i / 16 for i in ts)
]
vein = [turned(tip[0] - 14 - 36 * t, tip[1] - 3 - 8 * t) for t in (i / 8 for i in range(9))]
bud = (10 * math.sin(0.5 * 2.4), -180 - 78 * 0.5)
ux, uy = math.cos(math.radians(-32)), math.sin(math.radians(-32))
def second(t, side):
w = side * 15 * math.sin(math.pi * t) ** 0.8
return turned(bud[0] + ux * 46 * t - uy * w, bud[1] + uy * 46 * t + ux * w)
leaf2 = [second(t, s) for s, ts in ((-1, range(17)), (1, range(16, -1, -1))) for t in (i / 16 for i in ts)]
vein2 = [second(0.22 + 0.5 * t, 0) for t in (i / 6 for i in range(7))]
return stem, leaf, vein, turned(tip[0] - 32, tip[1] - 14), (leaf2, vein2, second(0.5, -0.5))
def drawing(frame, pose):
world = body(pose)
out = []
dome = oval(world, 0, -10, 150, 170, 180, 360, 48)
rim = [world(u, rim_y(u)) for u in (-150 + 300 * i / 30 for i in range(31))]
belly = oval(world, 0, -6.5, 130, 106, 180, 0, 40)
hood = [world(u, rim_y(u) + 54 * math.sin(math.pi * (u - 4) / 122) ** 0.7) for u in (4 + 122 * i / 24 for i in range(25))]
eyes = [oval(world, 44, 31, 6, pose["eye"], 0, 360, 16), oval(world, 84, 29, 6, pose["eye"], 0, 360, 16)]
ridges = [oval(world, 0, -10, 108, 124, a0, a1, 10) for a0, a1 in ((212, 236), (256, 284), (304, 328))]
stem, leaf, vein, leaf_seed, (leaf2, vein2, leaf2_seed) = sprout(world, pose["sprout"])
near, near_seed = leg(world, 70, pose["near"])
far, _ = leg(world, 104, pose["far"], DEPTH)
out += [
{"op": "fill", "layer": "far", "frame": frame, "polygon": poly(far), "color": "far", "part": "far leg"},
ink(frame, far, 7, pressure=(0.8, 1, 1, 0.8), layer="far", part="far leg"),
ink(frame, dome, 9, pressure=(0.7, 1, 1, 1, 0.8)),
ink(frame, rim, 6),
ink(frame, belly, 8, pressure=(0.8, 1, 1, 0.8)),
ink(frame, hood, 5, pressure=(0.6, 1, 1, 0.6)),
ink(frame, eyes[0], 4, pressure=(1, 1)),
ink(frame, eyes[1], 4, pressure=(1, 1)),
]
out += [ink(frame, r, 4, (8, 10), (0.4, 1, 0.5)) for r in ridges]
sprouting = [
ink(frame, stem, 6, (0, 10), (1, 0.9, 0.7), part="sprout"),
ink(frame, leaf, 5, pressure=(1, 1), part="leaf"),
ink(frame, vein, 3, (2, 8), (0.8, 0.4), part="leaf"),
ink(frame, near, 7, pressure=(0.8, 1, 1, 0.8), part="near leg"),
]
second = [
ink(frame, leaf2, 5, pressure=(1, 1), part="second leaf"),
ink(frame, vein2, 3, (2, 6), (0.8, 0.4), part="second leaf"),
]
out += second + sprouting if frame in REORDERED else sprouting + second
shade_shell = oval(world, 0, -10, 175, 195, 290, 362, 16) + oval(world, 0, -10, 112, 138, 362, 290, 16)
shade_belly = [world(-150 + 300 * i / 16, 70 - 34 * (i / 16) - 18 * math.sin(math.pi * i / 16)) for i in range(17)] + [
world(150, 140),
world(-150, 140),
]
out += [
{"op": "fill", "layer": "shade", "frame": frame, "polygon": poly(shade_shell), "color": "shade", "part": "body"},
{"op": "fill", "layer": "shade", "frame": frame, "polygon": poly(shade_belly), "color": "shade", "part": "body"},
]
out += [
ink(frame, oval(world, 0, -10, 139, 158, 196, 246, 14), 7, (24, 30), (0.3, 1, 0.4), "rim", "rim"),
ink(frame, oval(world, 0, -6.5, 119, 95, 148, 172, 8), 5, (10, 14), (0.3, 1, 0.3), "rim", "rim"),
]
spread = 1 - pose["bob"] / 60
shadow = [
(BODY[0] + 150 * spread * math.cos(2 * math.pi * i / 32), GROUND + 3 + 15 * spread * math.sin(2 * math.pi * i / 32))
for i in range(32)
]
out.append({"op": "fill", "layer": "shadow", "frame": frame, "polygon": poly(shadow), "color": "ground", "part": "shadow"})
seeds = {
"shell": world(-40, -90),
"body": world(-50, 40),
"face": world(64, 44),
"eye": world(44, 31),
"eye2": world(84, 29),
"leaf": leaf_seed,
"leaf2": leaf2_seed,
"leg": near_seed,
}
return out, seeds
def keys():
out = [
{"op": "palette", "add": "#17161d", "name": "ink"},
{"op": "palette", "add": "#5f7d4c", "name": "moss"},
{"op": "palette", "add": "#6b5643", "name": "bark"},
{"op": "palette", "add": "#20263a", "name": "dusk"},
{"op": "palette", "add": "#bff2ff", "name": "glow"},
{"op": "palette", "add": "#8dbb6a", "name": "leaf"},
{"op": "palette", "add": "#45372c", "name": "root"},
{"op": "palette", "add": "#2a211b", "name": "far"},
{"op": "palette", "add": "#44405a", "name": "shade"},
{"op": "palette", "add": "#eef6cf", "name": "rim"},
{"op": "palette", "add": "#3a3428", "name": "ground"},
]
extra = {
"shadow": {"blend": "multiply", "opacity": 0.35},
"shade": {"blend": "multiply", "opacity": 0.7, "clip": True},
"rim": {"clip": True},
}
first, hold, _ = IDLE[0]
for layer in LAYERS:
out.append(
{"op": "add", "layer": {"id": layer, "kind": "paint", "name": layer, "cels": [{"id": f"{layer}{first}", "frame": first, "hold": hold}], **extra.get(layer, {})}}
)
for frame, hold, _ in IDLE[1:] + WALK:
for layer in LAYERS:
out.append({"op": "cel", "new": layer, "frame": frame, "hold": hold, "id": f"{layer}{frame}"})
for frame, _, pose in IDLE + WALK:
ops, seeds = drawing(frame, pose)
out += ops
if frame == first:
colours = {"shell": "moss", "body": "bark", "face": "dusk", "eye": "glow", "eye2": "glow", "leaf": "leaf", "leg": "root", "leaf2": "leaf"}
for name, colour in colours.items():
x, y = seeds[name]
gap = 2 if name.startswith("eye") else 4
out.append({"op": "fill", "layer": "colour", "frame": frame, "at": [round(x, 1), round(y, 1)], "ref": "lines", "gap": gap, "color": colour})
return out
def leaf(bundle):
with open(f"{bundle}/doc.json") as f:
doc = json.load(f)
frames = {c["id"]: c["frame"] for layer in doc["layers"] for c in layer.get("cels", [])}
out = []
for key, _, pose in IDLE + WALK:
ops, seeds = drawing(frames[f"lines{key}"], pose)
out += [op for op in ops if op.get("part") == "second leaf"]
if key == IDLE[0][0]:
x, y = seeds["leaf2"]
fill = {"op": "fill", "layer": "colour", "frame": frames[f"colour{key}"], "at": [round(x, 1), round(y, 1)]}
out.append({**fill, "ref": "lines", "gap": 4, "color": "leaf"})
return out
def redraw(bundle):
with open(f"{bundle}/doc.json") as f:
doc = json.load(f)
frames = {c["id"]: c["frame"] for layer in doc["layers"] for c in layer.get("cels", [])}
out = []
for key, _, pose in IDLE + WALK:
ops, _ = drawing(frames[f"lines{key}"], pose)
drawn = [layer for layer in LAYERS if layer != "colour"]
counts = {layer: sum(1 for op in ops if op.get("layer") == layer) for layer in drawn}
out.append({"op": "rm", "ids": [f"{layer}{key}:s{i}" for layer in drawn for i in range(1, counts[layer] + 1)]})
out += ops
return out
if __name__ == "__main__":
modes = {"redraw": redraw, "leaf": leaf}
for op in modes[sys.argv[1]](sys.argv[2]) if sys.argv[1:2] and sys.argv[1] in modes else keys():
print(json.dumps(op))