Aquarium breach · qwen3.8-27b

Let's build this. A single self-contained index.html containing a canvas simulation.

Plan:
- Canvas ~960x560.
- Tank: glass walls, water line starts at, say, y=120 (water surface), tank interior from x=150 to 750, floor at y=480.
- Crack: user drags vertically along one side of the tank (e.g., right wall), below the water line. Show the crack preview. Breach button makes a hole in that spot.
- Physics: water level drops, outflow rate proportional to sqrt(max(0, waterSurfaceY - holeTopY))… actually outflow weakens as water level approaches the hole, and stops when the water no longer reaches the hole (waterSurfaceY > holeTopY, i.e., when surface is below top of hole).
- Jet: emitted from hole, initial horizontal velocity (outward), curving under gravity. Draw jet particles.
- Puddle: water that lands spreads on floor within the room walls. Model puddle as a collection of particles or a simple heightfield? Simplest: puddle is an array of "puddle droplets" that spread horizontally with damping, forming a blob. Even simpler: track puddle volume and spread radius, render as an ellipse that grows in width and gets lower height as volume grows, clamped at walls. That's "constrained by floor and room walls" — width limited by walls. Let's use a 1D heightfield across floor segments for a nicer spread: cells along floor, add water at impact point, diffuse between adjacent cells (water level seeks equilibrium), constrained to room bounds. That's simple and looks good.
- Objects: rocks (sink, heavy, resist current somewhat), toy (float, stays on water line), plants (fixed at bottom but bend/drift toward current), fish (swim, current pushes; if current exceeds threshold, get swept toward the breach, and if they fit the opening size, exit).
- When an object leaves water (water level below, or carried out), gravity applies, collides with floor, bounces.
- Glass fragments: on breach, generate shattering fragments around the opening; they rotate, collide with floor, and experience drag in water.
- Reset restores initial state.

Implementation details:

Coordinates: canvas W=960, H=560. Room: floor y=500, walls x=40 and x=920 (room walls). Tank: outer walls x=180..780, glass thickness 8. Interior x=188..772, top y=100, floor y=488. Initial water line y=170.

Breach side: pick right wall (x≈780). Crack: user clicks/drags vertically along right side of tank, between water line+something and tank floor. Crack is a vertical segment: center y, length ~40px. Show preview. Breach requires crack set and crack top below water line (initial water line). Requirement: "drag visible crack vertically on one side below the initial water line". So crack must be at y > waterLine (below water line). Enforce: crack top edge >= waterLine + 5.

Hole: after breach, the crack becomes a hole — remove glass segment. Hole extends from crackTop to crackBottom, and can widen slightly.

Water outflow: v = k * sqrt(max(0, holeTopY - waterLineY)) (Torricelli; holeTopY is y of top of hole (smaller y), waterLineY is y of surface; head = holeTopY - waterLineY when surface is above the top of hole; if surface is below top of hole, water still flows until surface is below bottom of hole: head = holeBottomY - waterLineY? For a rectangular opening, when surface is below the top, the wetted depth = min(holeBottom, ... ) - waterLine… head = min(holeBottomY, ... ). Let's use: wetDepth = clamp(holeBottomY - waterLineY, 0, holeH). v = 8 * sqrt(wetDepth) or so. When wetDepth <= 0, stop (water no longer reaches the hole). Also tank volume decreases: waterLevelY increases downward: volume = (waterLineY - tankBottom) * width; outflowRate per frame = v * jetWidth * dt → convert to area.

Jet: spawn particles at hole position (x = wall x + a bit, y between waterLine and holeBottom (clamped within hole)), velocity (vx = v*0.9 outward, vy = 0) with some randomness. Particles affected by gravity g. Render as blue circles. When particles hit floor (y >= floorY), add volume to puddle cell, remove particle (or splash a bit).

Water level fall: dVol = outflowRate*dt; waterLineY += dVol / tankWidth.

Current inside tank: near the hole, water flows toward it. For objects, current strength s = outflowV * falloff(distance to hole). Fish: have their own swim velocity (wandering), and the current pushes them toward the breach side; "swim against current" — fish steer to move away from breach, but if current > fishSpeed then they get carried. When fish exits (passes through hole, x > right wall) and small enough: if fish length < holeH, they exit; then gravity, fall to floor, become "escaped" (flail). Fish that are too big can't fit — get pushed but can't pass; they may just get stuck at hole. Let's keep all fish able to fit but vary sizes.

Rocks: in water, sink slowly with drag, slightly displaced by current; heavy so barely move. Toy: buoyant — when water level falls, rides the surface. If current is strong, drifts toward breach; floats at hole level, may be carried out (toy is small and fits). Plants: base fixed, tip bends in current direction (render as bent curve, bend ∝ current magnitude with smoothing).

Objects exiting: "movable objects that fit the opening are carried out by flow" — e.g., small rock or toy if strong flow: when outflowV high and object is near the hole at water level, they get ejected with velocity. Then fall under gravity, hit floor, bounce (coefficient of restitution 0.4), friction.

Glass fragments: on breach, spawn 8-14 shards around the hole with random outward velocities, rotation, angular velocity. Inside water: drag + slight buoyancy (glass sinks but slow, drag decelerates). Collide with floor, tank interior? Once they exit through hole… actually the hole is where the glass was; fragments are inside tank near wall. Some fall inside the tank (if water still above) with drag, some are flung outside. Keep simple: fragments have position/velocity/angle; while in water region, apply drag and partial buoyancy (glass is denser, slow sink), collide with floor, tank walls (except hole region), outside room floor.

Puddle: heightfield cells from x=40 to 920, cell size 8 → 110 cells. Each frame: for cells with height > 0, diffuse: move some to neighbors (if h_i > h_j, transfer (h_i - h_j)*0.15 /2). Add volume from landing jet particles. Render as a polygon: from leftmost wet cell to rightmost, height h[i] with smoothing. Draw as translucent blue path along top of floor.

Water level falls "continuously" — yes, each frame during outflow.

UI: buttons Breach, Reset. Maybe a small status text. Crack drag: pointer events on canvas; if phase='ready' and x is near right wall region (say 700<x<820), set crack from drag; simpler: user presses anywhere on right side of tank and drags vertically — crack is the dragged segment itself (from min to max of drag, clamped to tank interior, must be below water line). Show crack as jagged line. Then Breach enabled.

Let's allow left side too? "on one side" — right side is enough, but maybe support both sides based on which wall is near drag. Simpler: only right side. Actually supporting both adds symmetry complexity for jet direction. Right only? "drag visible crack vertically on one side" — one side is fine. But if user drags on left, we can snap to nearest wall and mirror. Let's support both — not hard: side = left or right, jet vx sign. Support both.

Fish rendering: simple ellipse with tail, direction by sign of vx.

State machine: 'ready' (can crack), 'breached' (simulating), reset to ready.

Let me write the code.

Structure:

const CFG = {...}
let state = { phase:'ready', waterY: INIT_WATER_Y, crack:null, crackSide:null, puddle: Float32Array, particles:[], objects:[], fish:[], shards:[], time:0 }

Initial objects:
- rocks: 3 at tank bottom, various sizes (r 12-20), one is small (r 9, fits hole).
- toy: duck-like, x=~300, y=waterLine, floats.
- plants: 3, base x 250, 400, 650, height 80-120, phase.
- fish: 4 fish, size ~16-24, random positions in water, each with wander timer.

Fish AI: wander: target direction changes; base speed 30. When breached: current at fish position c = outflowV * f(dist). Fish steers against: desiredVx = -sideSign * fishSpeed (away from breach). Actual velocity = desired + current influence: if current exceeds fish speed, net = away + (c - fishSpeed) in breach direction. Position += v*dt. Constrain inside water rect (if water level fell below fish, fish sinks? fish need water: water surface < fish.y (no water), fish "dies"/falls to floor and flails). If fish.x passes through hole (fish near hole, water reaches it, fish fits), it exits: set to flying state.

Actually simpler: when breached, fish get current force toward breach proportional to outflowV and (1 - distToHole/300). Fish's own swim is against it. Net vx. Fish stays inside until it reaches hole region; if |fish.y - holeCenterY| < holeH/2 + fishSize/2 and past inner wall, then it exits with velocity. If fish size > holeH then it can't pass; gets stuck (clamp x to wall - margin).

Water level falling: fish y clamped: if fish.y < waterY - 5? fish should stay below water surface: fish.y = max(fish.y, waterY + fish.r + 4). As water falls, fish descends. If waterY > tankBottom - 10, water gone, fish falls to floor.

Toy: y = waterY (floating). x drifts: when breached, drift toward hole with current * factor (light). If reaches hole and fits: carried out with jet velocity → flying.

Plants: base fixed to tank floor. Bend angle toward breach = clamp(currentAtBase, 0, 1) * 0.9 rad, smoothed. After breach, water falls and plants are… they stay put (attached), maybe fall when water is gone? Keep them standing, they wilt. That's fine.

Small rock: when outflow high and near hole, gets pulled; if current > rockDrag threshold, it slides toward hole and is ejected → flying with outward velocity.

Flying objects (all share physics): pos, vel, angle, angVel; gravity 900 px/s²; if in tank water region (x inside tank, y > waterY): drag vel *= (1-2*dt*...), buoyancy? Rocks sink: add downward buoyancy reduction (drag only). Collide: floor y=500: y = 500 - r, vy *= -0.4, vx *= 0.8, angVel *=0.7. Room walls x=40/920: bounce. Also can land in puddle (skip). Once on floor with low velocity, rest.

Fragments: similar but smaller, glass: in water, drag stronger and buoyancy slightly upward? Glass is denser than water — sinks slowly. Drag only.

Breach visuals: draw missing glass segment (jagged edges) on wall, fragments spawn.

Water rendering: tank water rect from waterY to tankBottom, with slightly wavy top (sin). Outside jet particles.

Puddle update: cells n = (920-40)/8 = 110.

Draw order: room background, floor, puddle, tank glass, plants, rocks, fish, toy, particles, fragments, crack preview, HUD.

Jet particles: each {x,y,vx,vy,r}. Spawn rate ∝ outflowV. Cap count at ~600.

Also waterline falls: tank width W_t = inner right-left = 584. Area lost = flowV * dt, flowV (px³/frame → px²). flowArea = v * wetDepth? Volumetric flow ~ v * wetDepth (per unit width). waterY += (v*wetDepth*dt)/innerW. Tune so it takes ~10-20 seconds to drain. Tune constant.

Time step: requestAnimationFrame, dt clamped to 0.033.

Let's write. Keep code clean.

Buttons: Breach (disabled until crack set), Reset.

Verify in browser after: place crack, breach, sample first outflow (jet curves down — check particle positions after a moment), water level falls, objects react; reset.

Let me write the file now.

Crack drag detail: on pointerdown in phase 'ready', if x within tank's side band (|x - wallX| < 60) and y between waterLine+10 and tankBottom-10: start crack drag with side determined by which wall closer. On pointermove, update crack = {side, top: min(y0,y1), bottom: max}. Ensure top >= waterLine+15. On pointerup: if length < 15, discard (or keep small?). Keep if >= 15. Render crack as jagged line along wall.

Breach: phase='breached'; spawn fragments along the crack; enable flow.

Hole: {side, top: crack.top - 6, bottom: crack.bottom + 6}.

Water surface: if waterY > hole.bottom → no flow. wetDepth = clamp(hole.bottom - waterY, 0, holeH). v = 9 * sqrt(wetDepth). When waterY is above hole.top: v = 9*sqrt(holeH)? use head = clamp(hole.bottom - waterY, 0, hole.bottom - hole.top) then v = 8*sqrt(head) + if waterY < hole.top, full: head=holeH → v=8*sqrt(50)≈56. Fine, tune.

Fish sizes: r 10-16; holeH ≈ crack length (~40-80) so all fit. Maybe make one "big fish" r 20 (length 40) — if holeH is small, might not fit? Keep all fitting; mention small ones get carried out.

Current falloff function: cur(x,y) = outflowV / 60 * exp(-dist/150) or similar.

Let's code.

For sampling verification: in browser I can inspect via JS: evaluate? the browser tool here: actions are reload, inspect, screenshot, motion, click, drag, key, type, scroll. inspect is probably DOM/console. Can I also add a hidden console.log for diagnostics or a state object window.__sim with getters, and inspect? inspect shows DOM and console — I can log values to console and read them in the inspect output. Plan: add a small diagnostic: window.sim = {phase, waterY, ...} and console.log on breach? Better: log periodically? Keep minimal: log outflow sample when breach triggered after ~1s. Or expose window.__aquarium getter and in inspect… inspect probably doesn't execute JS. Let's rely on console.log: on breach, log after 60 frames: waterY, particle positions, verify jet curve (particle y increasing, x moving outward). Just log a few snapshots.

Now write the file.

Render code for tank with hole: draw glass as lines with gap at hole for that wall.

Crack jagged rendering: deterministic zigzag: segments of 8px with alternating x offset 2px, seeded by index (use a fixed pseudo-random from index).

Let's write.

Plant rendering: bezier from base to tip, control points offset by bend direction. Leaves: a few blades.

Toy: small yellow duck: circular body + head + beak.

Fish: body ellipse, triangle tail, eye. Direction = sign of lastVx or facing.

Puddle rendering: build path: start at (leftWetX, floorY), lineTo along (x, floorY - h[i]) with smoothing, end right, close to floor.

Diffusion: for i in 1..n-2: if h[i]>0: d = (h[i]-h[i-1])*0.18; h[i-1]+=d/2; h[i]-=d/2… standard: for each adjacent pair, transfer (h[i]-h[i+1])*0.1/2 both ways. Two passes.

Add volume: jet particle hits floor at x → add to cell: h += r*r*0.02? Volume units: h is px. Add h[cell] += 1.2 per particle (tune). Also when water level falls, water from top of tank… only via jet.

Also drain: when waterY reaches hole.bottom, outflow stops; residual water in tank stays below hole.

Objects in tank bottom after drain: rocks stay; fish fall on floor inside tank? Tank interior floor is 488, room floor is 500. Objects inside tank fall to tank floor. Flying objects inside tank (before exit) collide with tank floor 488. OK: floorY = (x in tank interior) ? 488 : 500.

Fish exit: if breached, fish is at water level near hole and flow ongoing, and fish is small enough: set to flying with vx = sideSign * v, vy = -30.

Toy exit: similar.

Fragments initial: spawn at hole along crack with velocity outward (sideSign * rand(60,200), vy rand(-80,40)), angle random, angVel random.

Fragment collision in tank: hit walls other than hole? Just: fragments that stay inside: collide with tank floor and inner walls (clamped). Some flung outside will go through hole (since hole is open). Simplify: fragments are all subject to room/tank floor collision; no wall collision except room walls; some visually stay in tank. Fine.

Now let's write the file. HUD text: instructions + status (water level %, flow).

Code:

```html
<!doctype html>
<html><head><meta charset=utf8><title>Aquarium Breach</title>
<style>...</style></head>
<body>
<div id="wrap">
 <div id="bar">
   <button id="breachBtn" disabled>Breach</button>
   <button id="resetBtn">Reset</button>
   <span id="status">Drag a crack vertically along a tank wall (below the waterline), then press Breach.</span>
 </div>
 <canvas id="cv" width="960" height="560"></canvas>
</div>
<script>
...
</script>
</html>
```

Simulation constants:
W=960,H=560
FLOOR=500, ROOML=40, ROOMR=920
TANK: left wall inner x=190, right inner 770; glass thickness 8 → outer 182/778. TANK_TOP=100, TANK_BOT=488.
WATER0=180.

innerW = 770-190=580.

Water volume: (waterY - TANK_BOT) * innerW (px²).
Flow: v = 8*sqrt(head); areaFlow = v * head * 0.9? Let head max ~ (hole.bottom - WATER0) … crack around y 260-340: head ≈ 80. v≈71. areaFlow= v*head = 5700 px²/s → tank volume = (488-180)*580 = 178,000 → drains in 31s. A bit slow; use areaFlow = v*head*1.5 → ~20s. OK, tune with k=1.2.

Actually flow should reduce as head reduces — sqrt is enough.

dt: use seconds.

Jet spawn: rate = v * 1.5 particles/sec? Spawn n = v*dt*0.8 particles per frame at random y in [waterY, holeBottom] clamp within hole (if waterY above hole.top, then y in [hole.top, holeBottom], else [waterY, holeBottom]). x = holeX (wall inner ±). vx = v*(0.9+rand*0.2)*side, vy = rand(-10,10).

Particle update: vy += 900*dt; x+=vx dt; y+=vy dt. If y>=FLOOR: add puddle, spawn small splash? Just add. If x out of room bounds (shouldn't since within). Cap 700.

Render jet: for each particle, circle r 2-4, color rgba(90,170,255,0.8). Maybe draw as streak from prev pos to pos. Streak better: line from (x-vx*0.02, y-vy*0.02) to (x,y), lineWidth 3.

OK. Writing.

Also for fish "swim against current before being carried out" — implement as: fish has baseSpeed; when breached, away = -side; desired vx = away*baseSpeed; currentPull = cur; net = away*baseSpeed + side*max(0, cur - 0)*? Let cur be in px/s: cur = v * exp(-d/120) * 1.0. net vx = away*base + side*max(0, cur - base) * 0.9. So when cur<base, fish makes progress away; when cur>base, swept in. As water level drops, v decreases, fish may escape. Good.

Fish vertical: keep at preferred depth; clamp within water: y between waterY+15 and TANK_BOT-15. When water falls below fish.y… clamp y = min? if water thin, y = clamp(y, waterY+8, TANK_BOT-8). If TANK_BOT - waterY < 20 → water nearly gone, fish on floor: falling object, flail (angle wobbles).

Exit condition: if breached and flowOn and fish is within 30px of hole x (at inner wall), and |fish.y - holeMid| < (holeH+fishLen)/2, and flowOn: flying = {vx: side*(v*0.9), vy: -40, ...}.

Toy: floats y=waterY-6; x += (drift): in ready state, small bob and slight sway; when breached: x += cur*0.6*dt (toward hole). If reaches near hole and fits (toy width 30 < holeH): flying with vx side*v, vy -60. If holeH < 30: stuck at wall (toy is too big) — toy width 26, crack min 40? Force crack length min 30, max 120. Toy 26 always fits. Small rock r=8 (diameter 16) fits. Big rocks r 16-22 can't — "movable objects that fit the opening are carried out" — good, big rocks remain.

Rock current displacement: x += cur*0.15*dt, but only if rock is small (r<12); else 0.05. Friction.

Plants: bend toward hole (breach direction) proportional to current at base, smoothed; after flow stops, spring back slowly? Keep bend (water is gone). When no flow, spring back slightly: bend target 0.

OK, let's write the file.

HUD: status text updates: "Water: 78% • Outflow: active/stopped".

Console diagnostics: on breach, schedule logs at t=0.8s and t=2s: waterY (initial 180), sample jet particle (min/max x,y vs hole), objects. Log as [aq-diag].

Edge: drag on canvas — set touch-action none, use pointer events.

Crack render: jagged polyline on that wall x (wall center x: inner+4).

Breach: create hole; glass around opening: draw jagged edges at hole top and bottom.

Tank glass render: for each wall: top frame, left wall, right wall (with gap if hole on that side), bottom. If hole: draw jagged edge.

Let's write.

function drawTank(): strokes lineWidth 8, color #bfe6f2cc.

I'll write the full code, being careful with details.

Puddle cells: cellW=8, x0=ROOML(40) to ROOMR(920): n=110.

Render puddle: for i where h>0.2: path.

Add splash particles? Skip.

Now the code.

```js
const cv=document.getElementById('cv'),ctx=cv.getContext('2d');
const W=960,H=560;
const ROOML=40,ROOMR=920,FLOOR=500;
const TIL=190,TIR=770,TOP=100,TBOT=488; // inner
const GT=8;
const WATER0=180;
const CELL=8, PN=(ROOMR-ROOML)/CELL;

let S; // state

function initialState(){ return {
 phase:'ready', t:0, waterY:WATER0, crack:null, hole:null,
 puddle:new Float32Array(PN),
 jets:[], shards:[], flying:[],
 rocks:[
   {x:260,y:TBOT-14,r:16,rest:0},
   {x:430,y:TBOT-11,r:13,rest:0},
   {x:560,y:TBOT-8,r:9,rest:0},
 ],
 plants:[{x:240,h:110,ph:0.3,bend:0},{x:410,h:90,ph:1.7,bend:0},{x:660,h:120,ph:4.1,bend:0}],
 fish:[
   {x:300,y:260,r:14,vx:0,vy:0,face:1,wt:1,base:34},
   {x:420,y:320,r:12,vx:0,vy:0,face:-1,wt:2,base:30},
   {x:540,y:240,r:15,vx:0,vy:0,face:1,wt:0.5,base:38},
   {x:360,y:380,r:11,vx:0,vy:0,face:-1,wt:3,base:28},
 ],
 toy:{x:330,y:WATER0-7,r:13,face:1,flying:false},
 outflow:0, done:false,
};}
```

Toy initial y should be WATER0-7. Good.

Fish wander: wt timer; on timer, random direction/speed.

Update:

```js
function step(dt){
 S.t+=dt;
 // outflow
 let v=0, hole=S.hole;
 if(S.phase==='breached'&&hole){
   const head=Math.max(0,Math.min(hole.b, S.waterY> ? ... ))
```

head = hole.b - S.waterY clamp 0..(hole.b-hole.t).
v = head>0 ? 8*Math.sqrt(head) : 0.
S.outflow=v;
if v>0:
  S.waterY += (v*head*1.1*dt)/(TIR-TIL);
  if S.waterY > hole.b - 0.5, head will be ~0.
  spawn jet particles: n = v*dt*1.4; for i: y = rand within [max(hole.t, S.waterY+ (S.waterY<hole.t? 0:0)) ... ]. If waterY < hole.t: y in [hole.t, hole.b] but only part of hole is below water surface: actually when water surface above hole top, the jet exits across the full hole. y is uniform in [hole.t, hole.b]. Else y in [S.waterY, hole.b].
  x = side==='R' ? TIR+6 : TIL-6; vx = sideSign*(v*(0.85+0.25*rnd)); vy=(rnd-0.5)*30.
  cap jets length 900 (shift).

jet update: gravity 900; move; if y>=FLOOR-2: idx=((x-ROOML)/CELL)|0; puddle[idx]+= 2.2; small chance for splash particle? skip. remove.
if x<ROOML-20||x>ROOMR+20 remove (shouldn't).

puddle diffuse:
for pass in 2: for i in 1..PN-2:
  let f=(p[i]-p[i-1])*0.12; p[i-1]+=f*0.5;p[i]-=f*0.5;
  let g=(p[i]-p[i+1])*0.12; p[i+1]+=g*0.5;p[i]-=g*0.5;
also small evaporation: p[i]*= (1-0.0005)

objects update (fish, toy, rocks, plants) — behavior differs by phase.

Current at point: function curAt(x,y): if v<=0 return 0; d=distance to hole center (hx = side==='R'?TIR:TIL, hy=(hole.t+hole.b)/2); return v*Math.exp(-d/140);

fish:
if phase!=='breached' or v==0 (but fish is on floor after drain):
 normal wander.
wander: f.wt-=dt; if(f.wt<0){f.wt=1+rand*2; f.face = rand<0.5?-1:1; } f.vx = f.face*f.base*0.5 (gentle); also clamp position within water rect: x in [TIL+f.r+4, TIR-f.r-4], y in [waterY+10, TBOT-f.r-6]. If breached:
 cur=curAt; sideSign=hole.side==='R'?1:-1;
 away=-sideSign;
 net = away*f.base + sideSign*Math.max(0,cur-f.base*1.1);
 f.vx = net;
 f.x += f.vx*dt; f.face = f.vx>=0?1:-1 (when net large)
 y: follow water: f.y += (clamp target - y)*dt*2; target=clamp(f.y0? ...). Just: f.y=clamp(f.y, S.waterY+12, TBOT-f.r-6), if waterY+12 > TBOT-f.r-6 (water nearly gone): fish on floor: y=TBOT-f.r-4, wobble.
 x clamp within tank: TIL+4 to TIR-4 (until exit).
 exit check: hx inner: side R: f.x+f.r > TIR-2 && Math.abs(f.y-hy) < (hole.b-hole.t+f.r) → exit: push to flying {x:TIR+8, y:f.y, vx:sideSign*(v*0.9), vy:-50, r:f.r, type:'fish', ...}; remove from fish array. Only if hole fits: 2*f.r < holeH+10, else clamp x to TIR - f.r -2.
 
Actually fish also needs water to reach the hole: |f.y - hy| check handles that.

Toy:
y: float at S.waterY - 6 (smoothed: y += (target-y)*min(1,dt*5)); bob = sin(t*2)*1.5.
x: if ready: gentle sway toward center? small sine.
if breached and v>0: x += curAt(toy)*0.8*dt toward hole; face = sideSign.
if reaches hole && 26 < holeH: exit to flying, type 'toy', vx sideSign*v*0.8, vy -70.
If water too low for toy (waterY near TBOT), toy rests at bottom: y=TBOT-r-4.
if toy fits and waterY > hole.b (no more flow), toy stays floating inside; fine.

Rocks: if breached: r.r<12: x += sideSign*curAt*0.25*dt (toward hole), if reaches hole & fits: flying (ejected), vx sideSign*v, vy -30. Else: static, small nudge: x += sideSign*cur*0.04*dt. y stays at TBOT - r + (r? placed with y = TBOT - r*0.6 to appear half-buried). Let me store rock.y as center = TBOT - r*0.55.

Plants: target bend = sign toward hole * clamp(cur/120,0,1) * 0.8 if v>0 else 0; bend += (target-bend)*dt*3.

Flying objects (including fragments):
each: vy += 900*dt; if inWater(x,y): vy -= 160*dt (partial buoyancy); drag: k= inWater? 1.6: 0.15; vx-=vx*k*dt; vy-=vy*k*dt;
x+=vx*dt;y+=vy*dt; a+=va*dt;
floor collision: fy = (x>TIL&&x<TIR)? TBOT : FLOOR; if(y+r>fy){y=fy-r; vy*=-0.4; vx*=0.75; va*=0.6; if(|vy|<20) vy=0; if(y+r>=fy-0.5 && |vy|<5) rest: vx*=0.9...}
walls: if x<ROOML+r {x=ROOML+r;vx*=-0.5} similarly ROOMR.
fragments smaller r (3-6), type 'shard'.

Breach function:
S.phase='breached'; S.hole={side:S.crack.side, t:S.crack.top-6, b:S.crack.bottom+6};
shards: for i<12: pos along crack: y = t + (b-t)*i/11; x=wallX; vx=sideSign*(60+rnd*160); vy=(rnd-0.5)*120; r=2+rnd*4; a=rnd*6; va=(rnd-0.5)*10. Push to flying.
console diag schedule.

Diag:
```js
function diag(){
 const h=S.hole;
 let js=S.jets.slice(0,12).map(p=>`(${p.x.toFixed(0)},${p.y.toFixed(0)})`);
 console.log('[aq] waterY='+S.waterY.toFixed(1)+' outflow='+S.outflow.toFixed(1)+' jet samples='+js.join(' '));
}
```
call at t≈1.2 after breach.

Water render:
```js
if(S.waterY < TBOT){
 ctx.fillStyle='rgba(70,150,230,0.75)';
 ctx.beginPath();
 ctx.moveTo(TIL,TBOT);
 for(x=TIL..TIR step 10) lineTo(x, S.waterY + sin(x*0.05 + t*2)*2*(flowing?1:0.5));
 lineTo(TIR,TBOT); close; fill;
```
Also, if hole side is L or R, water inside tank is fine.

Walls: draw tank glass:
top: rect TIL-GT,TOP, (TIR-TIL)+2GT, GT
bottom: rect TIL-GT, TBOT, width, GT
left wall: rect TIL-GT, TOP, GT, TBOT-TOP
right: same at TIR. If hole on R: draw in two pieces: TOP to hole.t, and hole.b to TBOT. Jagged edge: small triangle.

Glass color 'rgba(190,230,245,0.55)' with stroke.

Crack preview: if S.crack && phase ready: draw jagged line on wall.

function jag(x,y0,y1,seed): segments of 8px, offset alternating ±2.5 with deterministic rnd: use s=Math.sin(seed)*43758 frac.

Room render: background wall color, floor rect from FLOOR to H, skirting line. Also a little rug? Skip.

HUD status text updates each frame (cheap enough, or every 0.2s): percent = (TBOT-waterY)/(TBOT-WATER0)*100.

Reset: S=initialState(); enable button; status default.

Breach button: disabled until S.crack (set length>=25 and top>WATER0+10).

Pointer handling:
```js
let drag=null;
cv.addEventListener('pointerdown',e=>{ if(S.phase!=='ready')return; const p=pt(e);
 // side bands: near left inner wall (x in TIL-70..TIL+20) or right (TIR-20..TIR+70)
 let side=null;
 if(p.x>TIR-15&&p.x<TIR+80) side='R';
 else if(p.x<TIL+15&&p.x>TIL-80) side='L';
 if(!side) return;
 const y0=clamp(p.y, WATER0+18, TBOT-10);
 drag={side,y0,y1:y0};
});
pointermove: if drag: drag.y1=clamp(p.y, WATER0+18, TBOT-10); S.crack={side:drag.side, top:min, bottom:max};
pointerup: if S.crack && (top-bottom) <25: S.crack=null; enable button accordingly.
```

Side band: right wall is at TIR..TIR+GT, band x TIR-15..TIR+90 (outside room too?) ROOMR=920, TIR+GT=778, fine.

Fish "respond to current" — yes, drift.

Now, fish exit: if fish exits and later lands on floor, draw flailing fish (angle wobble). Flying type fish: when on floor, va=0, a = sin(t*8)*0.3 (flail). Cute.

Toy flying: when on floor, angle settled.

Fragments on floor: just rest.

Also fish can be inside tank and water still up: fine.

Another: "water exits as a jet curving under gravity, water line falls continuously" ✓.

Let me write everything out.

Also for the crack: "drag visible crack vertically" — show crack while dragging and after release. Good.

Edge: if crack near bottom, water line may initially be above the top of hole; head is limited to holeH; as water falls below hole.t… head = min(hole.b, ... )-waterY = hole.b - waterY until 0 → "stops when water no longer reaches the opening" ✓.

Let me write the file.

Quickly test in the browser: reload, take a screenshot, drag a crack, trigger a breach, check the console, reset.

Initial scene looks good. Next, I'll drag a crack on the right wall (around x≈910, y from 300 to 400), then press Breach.

The crack has been set. Next, I'll click Breach and wait a bit, then check the console diagnostics and take a screenshot.

Breach is operating: glass shards, outflow active, plants bending toward the hole. Take a screenshot after a few seconds and check the console diagnostic results (jet curves downward, water level drops).