Aquarium breach · kimi-k3

Let me build this. Single index.html with canvas simulation. Plan:

- Canvas ~1000x600. Room: floor at bottom, walls. Tank: rectangle, glass, water inside, waterline.
- Crack: draggable handle on right side of tank, vertical positioning below waterline.
- Breach button: creates opening in right panel, glass fragments spawn.
- Water particles: use a simple particle system for outflow jet — spawn particles at opening with horizontal velocity proportional to sqrt(2*g*depth), gravity applied, land in puddle. Water level decreases as particles exit. Outflow stops when level below opening.
- Puddle: track escaped water volume; render puddle on floor with height = volume/width between walls, spread.
- Objects: rocks (sink, heavy), toy boat (floats at waterline), plants (bend toward current), fish (swim; near current get advected; some swept out; outside water fall with gravity and collide floor).
- Glass fragments: polygons with angular velocity, gravity, water drag (slower fall + resistance when below waterline... they're outside tank mostly), collide with floor, bounce.
- Fish inside water: wander; flow field near breach pulls them. If within opening range and close to right wall, they exit, become ballistic, land on floor, flop.
- Toy: floats on waterline, drifts with current, can be carried out if small enough.
- Rocks: rest on tank bottom; too big to fit through crack, stay.
- Plants: attached at bottom, bend angle proportional to local flow.

Reset: reinitialize state.

Verify with browser tool.

Let me write the code carefully but compactly.

Key physics:
- Tank: x from tankX0=120 to tankX1=620, y from tankY0=140 to tankY1=520 (bottom glass). Floor at y=560, room walls x=20 and x=980.
- Water level waterY starts at 190.
- Crack on right panel x=tankX1, draggable y between waterY and tankY1-10; crack height ~40 opening.
- Breach: spawn glass shards from the opening region, set breached=true.
- Outflow rate: if waterY < crackY (i.e., water above crack top... careful coordinates: y down). Opening occupies [crackY, crackY+crackH]. Water exits if waterY < crackY+crackH (water reaches opening). Effective head = max(0, (crackY+crackH?) ... ) Standard: v = sqrt(2g*(crackCenterY - waterY)) if waterY above opening top. Flow rate proportional to v * submerged opening height.
- Spawn water particles at x=tankX1, random y in submerged part of opening, vx = v, vy small random. Each particle represents volume dV; waterY += dV/tankWidth.
- Particles: gravity, when hit floor -> removed, add to puddle volume; also collide with room right wall.
- Puddle: volume V; puddle spans from tankX1 to right wall (and maybe under tank? just region right of tank between tankX1 and rightWallX). Height = V / span. Cap. Draw as water rect with meniscus. Also maybe small puddle spreads left of tank? Keep simple: floor region from tankX1 to right wall.

Actually water jet arcs out and lands; particles hitting floor convert to puddle at their x position; puddle height computed as volume/span and drawn flat — fine, "spreading puddle constrained by floor and room walls."

- Fish: state inWater. Movement: wander with sine; velocity += flow(x,y). Flow field: near opening, attract toward opening: flow = k * dir to opening * strength where strength ~ outflow v and falloff with distance. Fish "swim against current": they have a swim force opposite to flow initially; if flow exceeds swim capacity, they get swept. Give each fish a swimPower random; weaker ones swept.
- Fish exiting through opening: x > tankX1 and within opening y range and level reaching — transition to ballistic, gravity, land on floor, then flop (wiggle, no movement) in puddle.
- Toy: floats; y = waterY - small; x moves with current near breach; if reaches opening while level above opening top? Toy needs opening big enough — crack height 40, toy height ~16, fits. When toy x > tankX1 within opening range, becomes ballistic outside.
- Rocks: sit at bottom; maybe slight jitter from current but stay.
- Plants: base at bottom, segments bend: bend angle = base sway + flow-induced bend toward opening.
- Glass shards: at breach, spawn ~8 shards with velocities outward (mostly +x, slight up), angular velocity. In air: gravity. If y > waterY and x < tankX1 (inside tank, fell into water): apply drag and buoyancy (sink slowly). Collide with floor and tank bottom: bounce with restitution 0.3, friction; settle. Shards mostly fly right out, land on floor/in puddle.

Rendering: background room, tank glass (stroked rect, thicker right panel maybe broken), water with wavy surface line, objects, particles, puddle.

UI: crack handle — a red dashed line / handle triangle on right panel; drag with mouse (mousedown near handle). Breach and Reset buttons. Info text: water level, outflow status.

Waterline wobble: draw sine wave.

Also water inside tank sloshing: just animate surface wave phase.

Fish count 6, rocks 4, plants 4, toy 1.

Edge: water level can't drop below tank bottom; outflow stops when waterY >= crackY (opening top above waterline). Particles continue to fall.

Let me also add water particles count limit.

Write code.

Details for crack handle dragging: canvas mouse events; if not breached and mouse near (tankX1, crackY..crackY+crackH), drag to set crackY within [initialWaterY+10, tankY1-crackH-6].

Flow function:
```
function flowAt(x,y){
  if(!breached) return {x:0,y:0};
  if(y<waterY) return {x:0,y:0};
  const ox=tankX1, oy=Math.min(crackY+crackH, waterY); // target point
  // Actually target center of submerged opening
  ...
  const dx=ox-x, dy=oy-y; d=hypot
  strength = outV * 900/(d*d+400) capped
  return scaled
}
```
OutV updated each frame: head = max(0, submerged portion). If waterY < crackY+crackH: submerged top = max(waterY... wait y down: water surface at waterY, opening spans crackY (top) to crackY+crackH (bottom). Submerged if waterY < crackY+crackH. Head measured from waterY to submerged centroid. v = sqrt(2*g*head)*scale. Use g=500 px/s² scaled: v = sqrt(2*0.5*head)*k... just v = Math.sqrt(2*600*head)*0.6 tune later. Actually let's use v = Math.sqrt(2*g*head) with g=400, head ~ 200 → v=400 px/s. Good.

Spawn rate proportional to v; each particle dV = 400 (px²?), waterY += dV/(tankW) ... water area width ~ (tankX1-tankX0)=500. Lowering: dLevel = particleVolume/tankWidth. particleVolume ~ 300 → 0.6 px per particle. Spawn ~ v*0.15 per second → at v=400, 60 particles/s → 36 px/s drop. Too fast; tune: particleVolume 120 → 14px/s initial, slowing. Fine — head decreases as level drops, slowing naturally.

Puddle: each floor-landing particle adds its volume to puddleV; puddle height = puddleV / puddleSpan. span = rightWall - tankX1 - margins ~ 340. 120/340 ≈ 0.35px per particle... with many particles grows slowly. Maybe particle volume for puddle bigger: use same 120 → after 200 particles height 70px? 200*120/340≈70. ok.

Cap particles at ~600.

Shards also landing in puddle/floor.

Fish behavior detail: each fish has vx,vy, wander angle, swimPower (max accel against current, 60-160). Update: current c = flowAt. Net desired: fish accelerates opposite to current with swimPower; plus wander. If |c| > swimPower, net drift positive toward breach. Once fish center x > tankX1-5 and y within opening & breached: exit → state air, vy small, gravity. Lands on floor: flop state, angle jitter.

Toy: when in water, y follows waterY (bob), current pushes x. Exits similarly if opening fits (crackH 44 vs toy 14). In air: gravity, rotate slightly, bounce floor with restitution.

Rocks: apply small current force, cap so they mostly stay; slight drag movement then stop (friction). They stay since they don't fit opening (width ~30-38 < crackH? make rocks tall ~30, crack 44... spec says "movable objects that fit the opening can be carried out" — rocks sink so they resist; keep rocks immobile-ish: strong friction, they'll barely move). Fine.

Plants: draw as quadratic curves from base, tip offset by sway + current at mid height * factor.

Water render: fill rect from waterY to tankY1 inside tank with translucent blue, surface wave via path of sine. After breach, maybe slight tilt? keep flat.

Glass: left/top/bottom drawn always; right panel drawn as two segments above and below the opening after breach; before breach full panel with crack line at handle.

Crack visual before breach: jagged red line at crackY center on right panel, handle circle.

OK, write it.

Also "Check ... sample the early outflow" — I'll add a status readout (water level px, outflow speed, escaped count) to help verify.

Let me write the full file now.

Draw order: room bg, puddle, tank back glass, water, plants, rocks, toy, fish, water front tint?, particles, shards, glass front, crack handle, HUD.

Simpler: bg, puddle, water(inside), objects inside, particles, floor-landed objects (fish flopping, shards, toy) — objects outside tank drawn after tank glass so they appear in front. Keep single draw list: inside objects clipped? Not necessary; fish constrained to tank bounds anyway until exit.

I'll write ~450 lines. Go.

For floor collision: floorY=560. Puddle drawn on top of floor from tankX1..rightWall... Also water particles hitting floor between tankX1 and rightWall join puddle. Particles might fly over right wall? cap vx so they hit wall: wall collision: x>rightWall → vx=-vx*0.2, splash.

Also jet particles passing over puddle: when y+? >= floorY - puddleH and x within puddle span → merge into puddle (add volume, maybe splash particle). Simplify: if y >= floorY → merge. Puddle drawn with slight blue.

Fish in puddle? Fish exiting fly and land at floorY. ok.

Write now. Also HUD text inside page below canvas with buttons.

Code sketch:

```js
const W=1000,H=620;
const floorY=560, leftWall=24, rightWall=976;
const tank={x0:120,x1:620,y0:150,y1:520};
let crackY, crackH=46, breached=false, waterY0=195, waterY;
let parts=[], shards=[], fishes, rocks, plants, toy, puddleV=0, time, outV=0;
function reset(){...}
```

Fish reset positions random but seeded-ish (Math.random fine — "same initial scene" roughly; use fixed positions to be safe). Use deterministic positions.

Interaction: mousedown near handle -> dragging. Buttons Breach/Reset.

Shard spawn: 9 shards at x=tankX1, y in opening, vx 80..320, vy -160..80, angular.

Shard update: if outside tank (x>tankX1) or above water: gravity 700. If inside water (x<tankX1 && y>waterY): gravity*0.15, drag 0.98, terminal sink. Collide floor/tank bottom: bounce vy*=-0.3, vx*=0.7, av*=0.6; settle if slow. Also wall bounce.

Fish: size ~ 26x12 — fits opening (46). 

Flow strength: compute only if breached and waterY < crackY+crackH+... fish below waterline. c = dir*(outV*2200/(d²+2500)) capped at outV*1.2.

Toy: float offset; current pushes: toy.vx += c.x*dt... with drag.

Rocks: tiny push with high static threshold: if |c|> 200 move slightly... simpler: rocks don't move; spec says rocks sink — they demonstrate sinking if displaced? Rocks start at bottom, fine; during breach slight shudder. I'll give rocks small displacement under strong current with friction, capped so they can't reach opening.

Plants bend: tipX = sway + clamp(flowAt(mid).x *0.15).

Water surface wave drawing: amplitude 3 + outV*0.004.

Status div updates.

Now write file.

Also handle: "drag a visible crack vertically on one side below the initial waterline" — crack on right side. Clamp crackY in [waterY0+16, tank.y1-crackH-8].

Breach only once; after breach, disable drag & button.

Particles color lighter blue with alpha.

Alright, write index.html.

For verification: run browser, screenshot initial, click Breach, motion frames, check status text (water level dropping), reset, screenshot.

Let me write the code.

```html
<!DOCTYPE html>
<html><head><meta charset="utf-8"><title>Aquarium Breach</title>
<style> ... </style></head>
<body>
<h2>...</h2>
<canvas id="cv" width="1000" height="620"></canvas>
<div controls: button Breach, Reset, span status, hint</div>
<script>
...
</script></body></html>
```

JS main loop with fixed dt.

Write carefully.

Fish drawing: ellipse body + triangle tail, direction by vx sign; when flopping rotate.

Toy: little boat: hull trapezoid + mast.

Rocks: gray rounded polygons.

Plants: green curves.

Let me now write final code.

Particles update:
```
for p: p.vy += g*dt; p.x+=p.vx*dt; p.y+=p.vy*dt;
if(p.x > rightWall-6){p.x=rightWall-6;p.vx*=-0.25;p.vy*=0.8;}
if(p.y >= floorY){ puddleV += p.vol; remove; splash }
```
Also spawn: while(acc>0){ spawn; acc-=1 }
spawnAcc += spawnRate*dt; spawnRate = outV * 0.18 (particles/sec). particle vol: total outflow must match level drop: levelDrop = vol/tankW. vol=150 → at outV=350, 63/s → 63*150/500=19 px/s level drop. Hmm decent. Level ~ (crackY - waterY) ~150px to drain to opening → ~10s. Good.

Outflow velocity: head = max(0, min(crackY+crackH, ???)). Submerged: waterY < crackBottom. head = clamp( centroid - waterY ) where centroid = (max(waterY? no—top of submerged = max(crackY, waterY)... if waterY <= crackY fully submerged centroid = crackY+crackH/2; if waterY between, submerged from waterY to crackBottom centroid=(waterY+crackBottom)/2; head = centroid - waterY. v = sqrt(2*500*head)*1.0 → head 200 → 447 px/s. ok g=500.

Spawn y: random in submerged opening [max(crackY,waterY)+2, crackY+crackH-2]. vx = v*(0.9+0.2rand), vy = ±30.

Stop when waterY >= crackBottom - 1: outV=0.

Floor splash: maybe skip extra splash particles; small.

Puddle height: puddleV/ (rightWall - tank.x1 - 12) ... width=976-620-12=344. Draw from tank.x1+6 to rightWall-6 width 350. h = puddleV/350 cap 40.

Toy exit condition: breached && toy.x + w/2 > tank.x1 && toy.y within [crackY-?, crackBottom] && waterY < crackBottom. Then toy.free=true; outside: gravity, spin slight, floor bounce, rest.

Fish exit similar.

Fish flop: on floor, vy=0, flopTimer; draw wiggle.

Toy in water also gets vertical: toy.y approaches waterY - 6 + bob.

Toy current: toy.vx += (c.x - toy.vx)*min(1,3*dt)*0.5... plus drag.

Fish movement:
```
const c = flowAt(f.x, f.y);
f.wander += (rand-0.5)*3*dt;
let ax = Math.cos(f.wander)*30 + Math.sign(-c.x||1)*... 
```
Better: fish tries to swim against current: swim direction = -normalize(c) if |c|>5 else wander direction. accel = swimDir*swimPower + wander. velocity += (c + accel)*dt; cap speed. If |c| > swimPower → swept (net toward opening).

f.vx += (c.x + ax)*dt etc. Then constrain inside tank: if x<tank.x0+16 bounce; y clamp [waterY+10, tank.y1-12]; x < tank.x1-14 unless aligned with opening and breached → allow pass: if breached and f.x > tank.x1-16 and f.y>openingTop and f.y<crackBottom and |c.x|> f.swim... simply if f.x > tank.x1-10 and within opening y-range → exit.

To make fish near the breach get pulled: flow field attracts toward opening point, so their y adjusts. Good.

flowAt target: oy = clamp(centroidY of submerged opening) else crackY+crackH/2.

Let me finalize numbers: tank.y1=520 bottom inner? Glass thickness 8; inner bottom = 520. Tank outer rect y0=150..y1=528. Water from y0..inner bottom 520. Rocks rest y=520-r.

Crack clamp: [waterY0+16, 520-crackH-8].

Initial crackY = 330.

Now write everything. Also status: `Level: X px | Outflow: Y px/s | Escaped: N drops | Fish out: k`.

Loop with requestAnimationFrame, dt clamp 0.033.

Reset re-inits all; breach button enabled.

Write file now.

Plants bend with flow at their location: bend = clamp(flowAt(px, py).x * 0.25, -40, 60) plus sway sin.

Draw water: 
```
ctx.fillStyle='rgba(40,120,200,0.35)';
surface wave path: moveTo(tank.x0+6, waterY+ sin..) lineTo across; then rect down to 520.
```

Puddle draw: ellipse-ish rect with wavy top near floor.

Glass: stroke rgba(180,220,255,0.9) lineWidth 6 for left/top/bottom; right panel segments. Add highlight.

Crack handle: jagged line along right panel at crackY..+crackH in red + draggable circle at (tank.x1+14, mid).

OK write.

One more: shards "collide" with each other? Spec says fragments rotate, collide (with surfaces), resistance in water. Surface collisions suffice.

Time to write the actual file.

After writing, test with browser tool: load, screenshot, click Breach (button coordinates), motion, read status via inspect, click Reset, screenshot.

Coordinates: canvas at page; Breach button below canvas. I'll inspect to get layout.

Write code:

I'll be careful with fish initial positions: 6 fish spread, fixed array.

Toy: x=300.

Rocks: 4 at bottom: x 180,260,420,520.

Plants: x 160, 360, 470, 580 heights varying.

Full code below.

Initial scene looks good. Now drag the crack handle (viewport coordinates: canvas offset... canvas displayed at some scale). Canvas is 1000 wide but displayed at ~1000? Screenshot shows canvas from x~90 to 1090 in the 1200x800 viewport. Actually the wrap max-width 1020, canvas width 1000 displayed at ~1000. The handle at tank.x1+14=634 canvas coords → screen x ≈ 90 + 634*(1000/1000)? Canvas bounding box: left edge ~90, width ~1000. So handle at ~(90+634, canvasTop + mid). Canvas top ~170? Canvas y in DOM: h1 ~ 24px, canvas starts ~30... In screenshot, canvas top edge ~170? Screenshot is 1200x800 but viewport scaled? Canvas displayed from y~170? Hmm image shows canvas border from y≈170? Actually canvas top-left ~ (90,170)? No, the tank top is at y=150 canvas coords and appears at ~185 screen. Canvas top ≈ 35? tank y0=150 → screen 185, so canvas top = 35. Handle mid = crackY+23 = 353 → screen y = 35+353=388. Screenshot shows handle at ~(725,390). Good: screen x = 90+634=724. Matches.

Drag from (725,390) to (725,300) to move crack up. Then click Breach at (115,682). Then motion frames.

The crack moved up (now at ~y300 screen, mid ~300 → crackY ≈ 265 canvas). Good, drag works. Now click Breach and take motion frames.

Breach triggered: glass shards visible at the opening, outflow 259 px/s, level starting to rise (196 from 195). Let me capture motion frames a second later to check jet curve, waterline fall, puddle.

Working: jet curves downward, waterline falls (195→252), outflow weakens (259→130), puddle forms (capped 46px), shards on floor. Issue: the water surface wave at the breach area — water drawn across opening is fine. Note water draws past right panel? Water rect goes to tank.x1-5, fine.

One concern: fish out = 0 so far; crack was placed high (y≈265 canvas), water level falling toward it. Fish near surface are close; as level approaches crack, flow weakens. Fish may or may not be swept. The flow strength might not be enough to sweep fish against swimPower 60-170. Also toy hasn't been carried out — toy at x~400 stayed. Toy free condition requires waterY+10 > crackY and toy reaches right edge. Flow near surface pulls toy; outflow weak. Let me run longer to see fish/toy behavior. Also level dropped below crack top (265)? Level 252 < 265, so opening fully submerged still... wait crackY canvas ≈ 300screen-35=265. Level 252 < 265 means waterline above crack top — still fully submerged. It will stop when level reaches 265+46=311... level is falling (y increasing) toward 311.

Let me advance more time to see if fish get swept. Motion with bigger delta.

Outflow stopped at level 284 ≈ crack bottom (265+46=311? hmm crack was at ~265; level stopped at 284? submergedInfo: waterY >= bot-1 stops. bot = crackY+46. Level 284 < 311... but outflow reached 0 at 284? Wait — the crack was dragged: final drag toY=300 screen → canvas y = 300-35=265? Hmm, but actually screen scale: canvas CSS width maybe not 1000. Level stopped at 284 means bot ≈ 285 → crackY ≈ 239. Close enough — drag worked and flow stopped when water reached opening. 

Problem: no fish swept out (fish out 0) and toy not carried out. The requirement says fish initially swim against current before some are swept through, and movable objects can be carried out. Fish near opening (yellow/red at right, x~620 screen→530 canvas) experienced current but swimPower max 170 vs current at d~60: outV 259 * 2600/(3600+2600) ≈ 108 — less than swimPower for stronger fish but >60 for weakest. But fish escape requires y within [crackY, bot] = [239,285] — surface fish y clamped to waterY+12 ≈ 270s; as level fell to ~284, fish near surface were within opening range... but the current weakened as level fell. The yellow fish at x 530 close to right edge: d = 90 → mag = 259*2600/(8100+2600)=63 < most swimPowers. So no sweep.

To make sweeping reliably happen, I should strengthen near-field current and make the pull extend farther. Increase mag: outV * 5000/(d2+2000), cap 1.6*outV. At outV 250, d 100 → 250*5000/12000 = 104; d 50 → 278 capped 400. Weakest fish (swimPower 60) gets swept at d<~100. Good enough — "some are swept".

Also fish escape condition requires waterY < openingBottom (true while submerged) — ok.

Toy: current pulls toy.x via c.x*0.9 with drag; toy at x 300 far away — weak. That's fine ("can be carried out" if it drifts close). But to demonstrate, maybe increase flow reach. With 5000 scaling at d=320: 250*5000/(102400+2000)≈12 → toy drifts slowly right. Over ~10s of strong flow could reach. Borderline. Toy drag coefficient 1.6 vs accel 12*0.9 → terminal vx ≈ 6.7 px/s → won't make it. Acceptable: toy near the surface near breach gets carried. But to better satisfy "the toy floats... carried out by flow", I could reduce toy drag a bit (0.9) and raise its coupling. At d 320, c.x 12 → vx term 10.8, terminal 12 px/s... still slow. Let me just increase flow reach more: 7000/(d2+3000), and cap 1.5*outV. At d=320: 250*7000/105400 ≈ 16.6. Meh.

Alternative: scale flow with distance falloff 1/d instead of 1/d². mag = outV * 90/(d+40). At d=320: 250*90/360=62; d=50: 250. More realistic far-field entrainment. Toy at d 320 gets c.x~55 → toy.vx terminal ~30px/s with drag 1.6 → reaches wall in ~10s. Good. Fish swimPower 60-170 vs mag at d=60: 225 → all but strongest get swept when close. Hmm, "some are swept" — with swimPowers 60..170, at d=100 mag=160 → weaker 4 fish swept, strongest two resist. 

Use mag = outV * 90/(d+40), cap outV*1.4.

Toy coupling: toy.vx += (c.x*0.9 - toy.vx*1.6)*dt — the *dt on whole thing is wrong-ish; it's fine as relaxation. Increase: (c.x*1.4 - toy.vx*1.2)*dt.

Also rocks threshold 190: at d 50, mag up to 1.4*outV=350>190 → rocks shudder slightly. ok.

Plants bend c.x*0.22: at c.x 100 → 22px bend. good.

Fish "swim against current": accel = -c/cm*swimPower; net = c - swim dir*power. Swept when cm>power. OK.

Edit flowAt.

Reloaded to intact state (verifies reset too, since it re-inits). Now breach with default crack (330) and observe fish sweep.

The toy drifted right to the wall near the opening (visible top-right at wall). Plants visibly bend rightward. Waterline falling, jet curving. But fish out still 0 — fish aren't getting swept to the opening y-band [330,376]... fish clamp y to waterY+12; waterline at 305, crack top 330, so fish near the opening need y 330-376 which is below surface-clamp, ok. But fish near right edge: pink fish at x 310... The issue: flowAt targets cent = (max(crackY,waterY)+bot)/2 = (330+376)/2 = 353. Fish at y ~300 get pulled down and right. But fish swimPower up to 170 vs mag: at outV 250, d=150 → mag=250*90/190=118 < 170, < 150. Weak fish (60,82,104) swept if within d~200. But the weak fish (indices 0,1,2: orange, blue, yellow at left side) started far left. Wander is random; they may not approach.

Hmm — swimPower order: fx[i] leftmost = weakest. Weak fish are far from the breach, strong ones near it. Bad arrangement! Reverse: give fish near the breach lower swimPower. Change swimPower: 170 - i*22 (leftmost strongest, rightmost weakest). Then near fish (red at 560, yellow at 500) with 60-82 get swept.

Also once level falls below crackY (330), fish y clamp keeps them at waterY+12 > 342... still within opening [330,376] until level passes 364. Window is decent.

Make the change and retest. Also toy is now at wall x=tank.x1-w/2, and condition to free: waterY < openingBottom (376) true, waterY+10 > crackY → 315 > 330 false → not freed yet; as level falls to 330ish, toy frees. Good.

The pink fish is hugging the right wall near the bottom (y~500 screen → ~470 canvas) being pushed right, but not escaping because its y (470) is below opening bottom 376 — the flow pulls it toward centroid 353 but it's pinned at tank bottom clamp tank.y1-12=508... it should be pulled up. mag at d: fish at (695-90-? ... screen x 660-700 → canvas ~570-610, y~525screen→490canvas). dx≈20, dy=353-490=-137, d≈138. mag=322*90/178≈163 > swimPower(60 for i=5? pink hue 300 is index 4 → swimPower 175-4*23=83). So net drift toward opening: vy component = dy/d*mag + swim against = -0.99*(163-83) ≈ -79 px/s upward... but fish y clamp: f.y > tank.y1-12 → 508. Fish at 490 should move up. Over frames it stays ~490-500. Hmm, maybe fish wander pushes back down, and vertical clamp vy=-|vy|*0.5 when hitting bottom. Also fish exit requires y between crackY(330) and openingBottom(376). Pink fish slowly moving up: frame1 y~527, frame4 y~500. It is being pulled up. It may eventually reach the band.

Time budget is a concern. To make sweeping more decisive, reduce the y-clamp effect and strengthen vertical pull. Alternatively make fish wander weaker when current is strong — it already overrides wander when cm>8. The issue may be that mag decreases as outV drops and head falls. Level 277 < crackY 330, so submerged top = 330, head shrinks as level approaches 376.

Actually a simpler robust fix: increase near-field cap and pull: mag = outV*120/(d+30), cap 1.6*outV. At d 138, outV 322 → 230. net upward (230-83)*0.99 ≈ 145 px/s. Fish will reach the band and exit. Strong fish (175) at same spot: net 55 toward — also swept. Hmm "some" swept vs all — the far-left fish stay away since mag at d 400 = 322*120/430=90 < 175. Good enough: near fish swept, far fish resist.

Apply and retest quickly.

The toy got carried out and is in the puddle. But fish still 0 out. The red fish is pinned right at the opening (screen x ~685, y ~407 → canvas x ~595, y ~372 — within [330,376]!). Yet not escaping: condition requires f.x > tank.x1 - 12 = 608. Fish clamped at tank.x1-16 = 604 when not escaping! The clamp `else if (f.x > tank.x1 - 16)` keeps them at 604 < 608, so escape never triggers. Fix: escape check threshold should be >= the clamp: change escape condition to f.x > tank.x1 - 18, or reorder: check escape when f.x > tank.x1 - 20. Use tank.x1 - 18 < 604... 604 > 602 → use f.x > tank.x1 - 20 (=600). Fix that.

Excellent: fish out 3, toy out and falling/bouncing on floor, 3 fish flopping on the floor at right, blue fish swimming against current near opening but resisting, two weak-left fish... wait leftmost were strongest now; remaining 3 in tank resist. Rocks stay. Outflow weakening (164→136) as level approaches opening (level 339 → crackY 330... submerged top now 330, stops at 376). All key behaviors verified. Now test Reset.