gitbreathing

1import type { Frame, Meta, Piece } from 'ascii.rest';
2import { STYLES, type StyleId } from './styles';
3 
4export type BreathingOptions = {
5  styles: StyleId[];
6  power: number;
7  seed: string;
8  styleWeights?: Partial<Record<StyleId, number>>;
9  styleColors?: Partial<Record<StyleId, string[]>>;
10};
11 
12const COLS = 64;
13const ROWS = 30;
14const clamp = (value: number, min: number, max: number) => Math.max(min, Math.min(max, value));
15const hash = (value: string) => {
16  let result = 2166136261;
17  for (let i = 0; i < value.length; i++) result = Math.imul(result ^ value.charCodeAt(i), 16777619);
18  return result >>> 0;
19};
20const randomAt = (seed: number, index: number) => {
21  let value = (seed + Math.imul(index + 1, 0x9e3779b1)) >>> 0;
22  value ^= value >>> 16;
23  value = Math.imul(value, 0x7feb352d);
24  value ^= value >>> 15;
25  value = Math.imul(value, 0x846ca68b);
26  value ^= value >>> 16;
27  return (value >>> 0) / 4294967296;
28};
29 
30type Grid = { chars: string[][]; colors: number[][] };
31type Plot = (x: number, y: number, glyph: string, color: number) => void;
32 
33function makeGrid(): Grid {
34  return {
35    chars: Array.from({ length: ROWS }, () => Array(COLS).fill(' ')),
36    colors: Array.from({ length: ROWS }, () => Array(COLS).fill(0)),
37  };
38}
39 
40function line(plot: Plot, x1: number, y1: number, x2: number, y2: number, glyph: string, color: number, weight = 1) {
41  const steps = Math.max(1, Math.ceil(Math.max(Math.abs(x2 - x1), Math.abs(y2 - y1)) * 1.8));
42  for (let i = 0; i <= steps; i++) {
43    const t = i / steps;
44    const x = Math.round(x1 + (x2 - x1) * t);
45    const y = Math.round(y1 + (y2 - y1) * t);
46    for (let oy = -weight + 1; oy < weight; oy++) for (let ox = -weight + 1; ox < weight; ox++) {
47      if (ox * ox + oy * oy <= weight * weight) plot(x + ox, y + oy, glyph, color);
48    }
49  }
50}
51 
52function curve(plot: Plot, point: (t: number) => [number, number], glyph: string, color: number, steps = 100, weight = 1) {
53  let previous = point(0);
54  for (let i = 1; i <= steps; i++) {
55    const next = point(i / steps);
56    line(plot, previous[0], previous[1], next[0], next[1], glyph, color, weight);
57    previous = next;
58  }
59}
60 
61function drawMotif(id: StyleId, plot: Plot, color: number, power: number, phase: number, seed: number) {
62  const density = Math.round(2 + power * 7);
63  const wobble = (t: number, amount = 1) => Math.sin(t * Math.PI * 2 + phase) * amount;
64  switch (id) {
65    case 'sun': {
66      for (let arc = 0; arc < 3; arc++) {
67        const radius = 7 + arc * 3;
68        curve(plot, (t) => {
69          const a = -Math.PI * 0.9 + t * Math.PI * 1.8;
70          return [32 + Math.cos(a) * radius, 15 + Math.sin(a) * radius * 0.72];
71        }, arc === 1 ? '*' : '.', color + (arc === 2 ? 2 : 1), 70);
72      }
73      for (let i = 0; i < 12; i++) {
74        const a = i * Math.PI / 6;
75        const r1 = 11, r2 = 13 + power * 4;
76        line(plot, 32 + Math.cos(a) * r1, 15 + Math.sin(a) * r1 * 0.72, 32 + Math.cos(a) * r2, 15 + Math.sin(a) * r2 * 0.72, '+', color + 1);
77      }
78      break;
79    }
80    case 'moon': {
81      for (let arc = 0; arc < 4; arc++) {
82        const radius = 8 + arc * 2.3;
83        curve(plot, (t) => {
84          const a = -Math.PI * 0.72 + t * Math.PI * 1.42;
85          return [34 + Math.cos(a) * radius, 14 + Math.sin(a) * radius * 0.78];
86        }, arc % 2 ? ')' : '(', color + (arc % 2), 72);
87      }
88      break;
89    }
90    case 'water': {
91      for (let row = 0; row < 5 + density; row++) {
92        const y = 9 + row * 2;
93        curve(plot, (t) => [4 + t * 56, y + Math.sin(t * Math.PI * (2.1 + row * 0.12) + phase + row) * (2 + power * 2)], row % 2 ? '~' : '=', color + (row % 3), 90);
94      }
95      break;
96    }
97    case 'flame': {
98      for (let tongue = 0; tongue < 7; tongue++) {
99        const x = 9 + tongue * 7;
100        curve(plot, (t) => [x + Math.sin(t * Math.PI * 2 + tongue) * (1.5 + power * 2), 25 - t * (12 + power * 8) + Math.sin(t * Math.PI * 3 + phase) * 2], tongue % 2 ? '/' : '^', color + (tongue % 3), 42);
101      }
102      break;
103    }
104    case 'thunder': {
105      for (let bolt = 0; bolt < 4 + density / 2; bolt++) {
106        let x = 5 + randomAt(seed, bolt) * 50;
107        let y = 3 + randomAt(seed, bolt + 50) * 9;
108        for (let part = 0; part < 5; part++) {
109          const nx = x + (randomAt(seed, bolt * 9 + part) - 0.25) * 9;
110          const ny = y + 2 + randomAt(seed, bolt * 13 + part) * 4;
111          line(plot, x, y, nx, ny, part % 2 ? '/' : '\\', color + (part % 3), 1);
112          x = nx; y = ny;
113        }
114      }
115      break;
116    }
117    case 'wind': {
118      for (let swirl = 0; swirl < 3; swirl++) {
119        curve(plot, (t) => {
120          const a = t * Math.PI * (2.2 + swirl * 0.4) + phase;
121          const r = 2 + t * (11 + swirl * 3);
122          return [32 + Math.cos(a) * r * 1.7, 15 + Math.sin(a) * r * 0.72];
123        }, swirl === 1 ? '~' : '-', color + swirl, 100);
124      }
125      break;
126    }
127    case 'stone': {
128      for (let crack = 0; crack < 7; crack++) {
129        let x = 5 + randomAt(seed, crack) * 54;
130        let y = 4 + randomAt(seed, crack + 80) * 20;
131        for (let segment = 0; segment < 4; segment++) {
132          const nx = x + (randomAt(seed, crack * 11 + segment) - 0.5) * 12;
133          const ny = y + (randomAt(seed, crack * 17 + segment) - 0.5) * 8;
134          line(plot, x, y, nx, ny, segment % 2 ? '#' : '+', color + (segment % 3), 1);
135          x = nx; y = ny;
136        }
137      }
138      break;
139    }
140    case 'insect': {
141      for (let wing = 0; wing < 4; wing++) {
142        const side = wing % 2 ? 1 : -1;
143        const upper = wing < 2;
144        curve(plot, (t) => [32 + side * Math.sin(t * Math.PI) * (5 + t * 14), 14 + (upper ? -1 : 1) * t * 10 + Math.sin(t * Math.PI) * (upper ? -1 : 1) * 4], wing % 2 ? ':' : '.', color + (wing % 3), 60);
145      }
146      break;
147    }
148    case 'serpent': {
149      for (let coil = 0; coil < 3; coil++) {
150        curve(plot, (t) => [4 + t * 56, 15 + Math.sin(t * Math.PI * (2.5 + coil * 0.55) + phase + coil) * (4 + coil * 2)], coil === 1 ? 'S' : '~', color + coil, 100);
151      }
152      break;
153    }
154    case 'flower': {
155      for (let bloom = 0; bloom < 3; bloom++) {
156        const cx = 13 + bloom * 19, cy = 13 + (bloom % 2) * 5;
157        for (let petal = 0; petal < 8; petal++) {
158          const a = petal * Math.PI / 4;
159          curve(plot, (t) => [cx + Math.cos(a) * (2 + 7 * Math.sin(t * Math.PI)), cy + Math.sin(a) * (1 + 5 * Math.sin(t * Math.PI))], petal % 2 ? 'o' : '*', color + (petal % 3), 28);
160        }
161      }
162      break;
163    }
164    case 'love': {
165      for (let ribbon = 0; ribbon < 3; ribbon++) {
166        curve(plot, (t) => {
167          const a = t * Math.PI * 2 + phase + ribbon * 0.8;
168          const x = 16 * Math.pow(Math.sin(a), 3);
169          const y = 13 * Math.cos(a) - 5 * Math.cos(2 * a) - 2 * Math.cos(3 * a) - Math.cos(4 * a);
170          return [32 + x * (0.65 + ribbon * 0.13), 15 - y * (0.42 + ribbon * 0.08)];
171        }, ribbon === 1 ? '@' : '~', color + ribbon, 100);
172      }
173      break;
174    }
175    case 'sound': {
176      for (let ring = 0; ring < 6; ring++) {
177        const rx = 7 + ring * 4, ry = 3 + ring * 2;
178        curve(plot, (t) => {
179          const a = t * Math.PI * 2;
180          return [32 + Math.cos(a) * rx, 15 + Math.sin(a) * ry];
181        }, ring % 2 ? ')' : '(', color + (ring % 3), 72);
182      }
183      break;
184    }
185    case 'beast': {
186      for (let claw = 0; claw < 5; claw++) {
187        const x = 8 + claw * 10;
188        line(plot, x, 25, x + 9 + claw, 5 + (claw % 2) * 4, claw % 2 ? '/' : 'X', color + (claw % 3), 1);
189        line(plot, x + 2, 24, x + 11 + claw, 7 + (claw % 2) * 4, '\\', color + 1, 1);
190      }
191      break;
192    }
193    case 'mist': {
194      for (let bank = 0; bank < 8; bank++) {
195        const y = 5 + bank * 3;
196        curve(plot, (t) => [2 + t * 60, y + Math.sin(t * Math.PI * 2.2 + bank * 0.75 + phase) * (1.5 + power)], bank % 2 ? ':' : '~', color + (bank % 3), 80);
197      }
198      break;
199    }
200  }
201}
202 
203export function createBreathingPiece(options: BreathingOptions): Piece<BreathingOptions> {
204  const styles: StyleId[] = options.styles.length ? options.styles : ['sun'];
205  const palette = styles.flatMap((id) => {
206    const custom = options.styleColors?.[id];
207    return custom?.length ? custom.slice(0, 3) : [...STYLES[id].colors];
208  });
209  const meta = {
210    name: 'gitbreathing',
211    category: 'effects',
212    note: 'a contribution-powered breathing slash in animated ascii',
213    cols: COLS,
214    rows: ROWS,
215    fps: 12,
216    loop: 2,
217    palette,
218    ground: '#080a10',
219    cell: 2,
220    options,
221  } satisfies Meta<BreathingOptions>;
222 
223  const piece: Piece<BreathingOptions> = {
224    meta,
225    default: (overrides = {}) => {
226      const config = { ...options, ...overrides };
227      const active: StyleId[] = config.styles.length ? config.styles : ['sun'];
228      const colors = active.flatMap((id) => {
229        const custom = config.styleColors?.[id];
230        return custom?.length ? custom.slice(0, 3) : [...STYLES[id].colors];
231      });
232      const seed = hash(config.seed);
233      const power = clamp(config.power, 0, 1);
234 
235      return (time, env) => {
236        const grid = makeGrid();
237        const plot: Plot = (x, y, glyph, color) => {
238          const px = Math.round(x), py = Math.round(y);
239          if (px < 0 || py < 0 || px >= COLS || py >= ROWS || glyph === ' ') return;
240          grid.chars[py][px] = glyph;
241          grid.colors[py][px] = clamp(color, 0, colors.length - 1);
242        };
243 
244        const phase = time * Math.PI * 2;
245        const layers = Math.max(1, Math.round(1 + power * 3));
246        for (let layer = 0; layer < layers; layer++) {
247          const yShift = Math.sin(phase + layer * 0.8) * (0.6 + power);
248          line(plot, 7, 24 - layer * 2 + yShift, 57, 5 - layer * 1.4 + yShift, layer === 0 ? '@' : layer === 1 ? '#' : '*', Math.min(colors.length - 1, layer), layer === 0 ? 2 : 1);
249        }
250 
251        active.forEach((id, index) => {
252          const weight = clamp(config.styleWeights?.[id] ?? 1, 0, 3);
253          if (weight <= 0) return;
254          const colorOffset = active.slice(0, index).reduce((sum, previous) => {
255            const custom = config.styleColors?.[previous];
256            return sum + (custom?.length ? Math.min(3, custom.length) : 3);
257          }, 0);
258          if (power > 0.04) drawMotif(id, plot, colorOffset, clamp(power * weight, 0, 1), phase + index * 0.62, seed ^ hash(id));
259        });
260 
261        const particles = Math.floor(8 + power * 52);
262        for (let i = 0; i < particles; i++) {
263          const x = Math.floor(randomAt(seed, i) * COLS);
264          const y = Math.floor(randomAt(seed, i + 900) * ROWS);
265          const pulse = Math.sin(phase * 1.6 + randomAt(seed, i + 1800) * 6);
266          if (pulse > 0.35) plot(x, y, i % 4 === 0 ? '*' : i % 3 === 0 ? '+' : '.', Math.floor(randomAt(seed, i + 2700) * colors.length));
267        }
268 
269        if (env?.color) {
270          for (let y = 0; y < ROWS; y++) for (let x = 0; x < COLS; x++) {
271            env.color[y * COLS + x] = grid.colors[y][x];
272          }
273        }
274        return grid.chars.map((row) => row.join('')).join('\n');
275      };
276    },
277  };
278  return piece;
279}
280