Run Detail
completedernie-5.5-flash-previewRecorded for these videos
27:18Gemini 4 Hydrogen: Cheaper Tokens, More Expensive Answers?
Nov 13, 2026 · YouTube
18:40ERNIE 5.5 Flash Preview vs GLM 5.3 Flash: Baidu's new model is very impressive!
Nov 11, 2026 · YouTube
36:22Fable 5.2 robbing me blind, plus: Nex AGI's N2.6 vs GLM 5.3 Flash
Nov 11, 2026 · YouTube
14:03Gemini 4 Carbon: Can it handle my challenges? (First look with one-shot coding tests)
Nov 10, 2026 · YouTube
47:51Ranking major U.S. Open-Weights Models. (Where does Ripple 65B fit in?)
Nov 6, 2026 · YouTube
10:57"Crouton Alpha": the latest super-efficient coding model by Meta?
Nov 3, 2026 · YouTube
38:58Testing Particle-1: a post-trained DeepSeek V4.1 Flash specializing in coding and efficiency
Oct 28, 2026 · YouTube
22:14GPT-6.1 Terra Pro vs Terra: How Much Better Is Pro?
Oct 27, 2026 · YouTube
29:55Kimi K3.1 Pro Looked Incredible. Then I Kept Testing.
Oct 26, 2026 · YouTube
31:28Is this company reselling GPT Sol 6.1 at a loss (for non-agentic/text-only)?🤔 Is this sustainable?
Oct 20, 2026 · YouTube
17:58Nemotron 3.5 Super VL vs Opus 5.5: Testing NVIDIA’s new coding juggernaut
Oct 15, 2026 · YouTube
16:04Testing a *massive* new open-weights model 🤯: Muse Spark Open (vs. Nemotron, Opus 5.5, and more)
Oct 15, 2026 · YouTube
16:43Gemini 4 Argon: Great 🐈 Animation, but a broken escalator. (Coding challenge vs Opus 5.5, Sol 6.1)
Oct 13, 2026 · YouTube
16:37Meta's new "Muse Wonder" AI is impressive... but can it compete with Anthropic's models?
Oct 12, 2026 · YouTube
11:12WOW... Haiku 5.5 is very impressive. RIP OpenAI?
Oct 7, 2026 · YouTube
22:47Mistral Large 4 Is Cheap. But Is It Good Enough to Compete?
Oct 6, 2026 · YouTube
22:02Is Pareto 26.10 Preview Just Routing to GPT Sol? I Tested It Against Sol 6.1 Pro
Oct 1, 2026 · YouTube
11:22I Tested Sonnet 5.5 Against Opus 5.5. Is It Actually Cheaper?
Sep 28, 2026 · YouTube
30:00Did Elon Musk's team "train the gay away"... and make Grok 4.7 worse?
Sep 26, 2026 · YouTube
19:21I Tested the Stealth "Space Bunny Alpha" Model Before It Went Offline
Sep 23, 2026 · YouTube
10:58So... how much better is Claude Opus 5.5 vs. GPT-6 Sol, really?
Sep 23, 2026 · YouTube
9:38Claude Opus 5.5... the BEST new model for coding!! 🤩
Sep 22, 2026 · YouTube
29:00Grok 4.7: improved, but GLM 5.3 FlashX beat it anyway (benchmark against Gemini, Sol, etc.)
Sep 22, 2026 · YouTube
Provider
openrouter
Challenge Version
v1.0
Turns
1
Duration
242.8s
Total Tokens
73,623
Input Tokens
433
Output Tokens
73,190
Reasoning Tokens
67,722
Reasoning Effort
high
Est. Cost
$0.0828
Started
11/10/2026, 8:53:42 PM
OR Provider
Baidu
Finish Reason
stop
Generation ID
gen-1794344022-srV09WvHXMIq0YjAR6r4
Turns (1)
Turn #1
433 in73,190 out67,722 reasoning73,623 total242.8s
user
You write simulations where the interesting behavior is supposed to emerge rather than be animated by hand.
Build me a single HTML page: a side-view escalator carrying 15 to 20 people. Then the escalator reverses, at high speed.
The build
- Side view. 15 to 20 figures standing on the steps, riding normally before anything goes wrong.
- A control I can press to throw it into reverse, and press again to put it back. Reversal happens fast enough to take everyone off their feet.
- What follows comes out of the simulation. People stumble, collide, slide, and pile up against each other; a figure that is down is an obstacle to the ones arriving behind it.
- Figures get up again when they have the room and the footing.
- No scripted disaster. No keyframed pile, no timeline, no figure that falls because the clock said so. Every figure runs the same rules. If you special-case anything, say so in the notes.
- The art is yours. Stick figures are fine if they move well.
House rules
- One file. Everything inline — no CDN, no external stylesheet, font, script or image.
data:URIs are fine. - No libraries. No physics engine — write your own.
- No network at runtime.
- No
localStorage,sessionStorage, cookies orindexedDB— sandboxed frame, they throw. - Return the file as exactly one fenced
htmlblock.
Answer in exactly these sections
The model
One paragraph, before the file: how a person is represented, what makes one lose balance, and what happens when two of them occupy the same place.
The page
The single fenced html block.
What it actually does
Having written it, what does the page do when the escalator reverses? Name anything you special-cased or nudged. Say what it does badly — I am going to press the button and watch.
assistant
The model
Each rider is one rigid rod (their body) balanced on a single point — the feet — which makes them an inverted pendulum: standing perfectly over the feet is unstable, so an upright rider runs a limited balance controller (a clamped PD torque at the ankle) that holds the lean angle near zero. The feet are planted to whichever step is underneath, so the base is dragged at the step's velocity, and the horizontal acceleration of that base is what drives the topple equation — a fast enough yank of the base produces a disturbance torque the controller's clamp can't answer, lean runs away past a commit angle, and the rider goes over. Once the body reaches the incline it slides (gravity down-slope versus kinetic friction to the moving step) and collides. Two overlapping bodies are separated by a positional push along the line between them plus an inelastic velocity impulse, sampled at three circles down each body; because the impulse lands off-centre it also nudges lean, so a downed figure — a low, wide, near-horizontal capsule — is a genuine obstacle that the bodies arriving behind it shove against, climb, and get knocked over by. A downed rider that has room (few touching neighbours), footing (on the surface) and low speed runs the same get-up rule as everyone else and stands back up. Every figure runs identical rules; only starting position and a tiny random lean/phase differ.
The page
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width,initial-scale=1">
<title>Escalator Reversal</title>
<style>
html,body{margin:0;height:100%;background:#0b0e14;color:#cbd5e1;font-family:system-ui,sans-serif;overflow:hidden}
#wrap{position:relative;width:100vw;height:100vh;display:flex;align-items:center;justify-content:center}
canvas{background:#0e1117;border-radius:10px;box-shadow:0 10px 40px rgba(0,0,0,.6);max-width:100%;max-height:100%}
#ui{position:absolute;top:14px;left:50%;transform:translateX(-50%)}
button{font:600 15px system-ui,sans-serif;padding:10px 22px;border:0;border-radius:8px;cursor:pointer;
color:#0b0e14;background:#79e0b8;box-shadow:0 4px 14px rgba(0,0,0,.4);transition:transform .05s,background .2s}
button:active{transform:translateY(1px)}
button.rev{background:#ff5f56;color:#fff}
#hint{position:absolute;bottom:12px;left:50%;transform:translateX(-50%);font-size:13px;opacity:.55}
</style>
</head>
<body>
<div id="wrap">
<canvas id="c" width="960" height="600"></canvas>
<div id="ui"><button id="btn">REVERSE</button></div>
<div id="hint">18 riders · identical rules · press to throw it into reverse</div>
</div>
<script>
(function(){
"use strict";
const cv=document.getElementById('c'), ctx=cv.getContext('2d');
const W=cv.width, H=cv.height;
const btn=document.getElementById('btn');
const clamp=(v,a,b)=>v<a?a:v>b?b:v;
/* ---------- escalator geometry (side view incline) ---------- */
const IM=(function(){
const P0={x:150,y:470}, P1={x:812,y:196}; // bottom, top of the incline
const dx=P1.x-P0.x, dy=P1.y-P0.y, L=Math.hypot(dx,dy);
const dUp={x:dx/L,y:dy/L}; // unit, up-slope
const nrm={x:dUp.y,y:-dUp.x}; // unit, out of the step surface
return {P0,P1,dUp,nrm,L};
})();
/* ---------- constants ---------- */
const G=1500, PH=46; // gravity, body length (px)
const KG=3*G/(2*PH); // gravity topple coeff
const KB=3/(2*PH); // base-accel -> lean coupling
const KP=150, KD=16, AMAX=9; // balance controller + clamp
const A_TOPPLE=0.35; // commit-to-fall lean
const RISE_RATE=1.9, GETUP_DELAY=0.7; // get-up
const KFRIC=5, FKMAX=950; // sliding friction to step
const CR=7.5, CORR=0.35, REST_COL=0.05, KNOCK=0.02; // collisions
const CROWD_MAX=1;
const VUP=24, VREV=-150, JERK=550; // speeds + reversal jerk
const WALL_LO=14, WALL_HI=IM.L-14;
const N=18;
const A_HI=Math.atan2(IM.dUp.x,-IM.dUp.y); // lie along incline, head up-slope
const A_LO=Math.atan2(-IM.dUp.x,IM.dUp.y); // lie along incline, head down-slope
/* ---------- escalator state ---------- */
const esc={speed:VUP, target:VUP, accel:0, scroll:0};
/* ---------- coordinate helpers ---------- */
function baseWorld(p){return {x:IM.P0.x+IM.dUp.x*p.s+IM.nrm.x*p.h, y:IM.P0.y+IM.dUp.y*p.s+IM.nrm.y*p.h};}
function baseVelWorld(p){return {x:IM.dUp.x*p.vs+IM.nrm.x*p.vh, y:IM.dUp.y*p.vs+IM.nrm.y*p.vh};}
function setBaseVelWorld(p,vx,vy){p.vs=vx*IM.dUp.x+vy*IM.dUp.y; p.vh=vx*IM.nrm.x+vy*IM.nrm.y;}
function addBaseWorld(p,wx,wy){
p.s+=wx*IM.dUp.x+wy*IM.dUp.y; p.h+=wx*IM.nrm.x+wy*IM.nrm.y;
if(p.h<0)p.h=0; else if(p.h>60)p.h=60;
if(p.s<WALL_LO)p.s=WALL_LO; else if(p.s>WALL_HI)p.s=WALL_HI;
}
function bodyCircles(p){
const b=baseWorld(p), ax=Math.sin(p.a), ay=-Math.cos(p.a), fr=[0.16,0.5,0.84], o=[];
for(let i=0;i<3;i++){o.push({x:b.x+ax*PH*fr[i], y:b.y+ay*PH*fr[i]});}
return o;
}
/* ---------- person ---------- */
class Person{
constructor(s){
this.s=s; this.h=0; this.vs=esc.speed; this.vh=0;
this.a=(Math.random()-0.5)*0.04; this.av=0; // lean from vertical, lean rate
this.state=0; this.t=0; this.calm=0; this.crowd=0; // 0 ride 1 topple 2 down 3 rising
this.wob=Math.random()*7; this.circ=null;
}
setState(s){ this.state=s; this.t=0; if(s!==2) this.calm=0; }
integrate(h){
const planted=(this.state===0||this.state===3);
let Ax=0;
if(planted){ // feet locked to the step
this.vs=esc.speed; this.vh=0;
Ax=esc.accel*IM.dUp.x; // horizontal base accel = disturbance
}else{ // free body sliding on the incline
this.vs+=(G*IM.dUp.y)*h; // gravity down-slope
const dvt=esc.speed-this.vs; // kinetic friction drags toward step
this.vs+=clamp(dvt*KFRIC,-FKMAX*h,FKMAX*h);
this.vh+=(G*IM.nrm.y)*h; // gravity into surface
}
this.s+=this.vs*h; this.h+=this.vh*h;
if(this.h<0){this.h=0; if(this.vh<0)this.vh=0;}
if(this.s<WALL_LO){this.s=WALL_LO; if(this.vs<0)this.vs=0;}
if(this.s>WALL_HI){this.s=WALL_HI; if(this.vs>0)this.vs=0;}
switch(this.state){
case 0:{ // ride: active balance
if(this.h>2.5){ this.setState(1); break; } // shoved off the step
let aA=KG*Math.sin(this.a)-KB*Ax*Math.cos(this.a);
aA+=clamp(-KP*this.a-KD*this.av,-AMAX,AMAX);
this.av+=aA*h; this.av*=1-0.6*h; this.a+=this.av*h;
if(Math.abs(this.a)>A_TOPPLE) this.setState(1);
break;
}
case 1:{ // topple: no control, gravity finishes it
const aA=KG*Math.sin(this.a);
this.av+=aA*h; this.av*=1-0.3*h; this.a+=this.av*h;
if(this.a>=A_HI){this.a=A_HI; this.av*=-0.1; this.setState(2);}
else if(this.a<=A_LO){this.a=A_LO; this.av*=-0.1; this.setState(2);}
break;
}
case 2:{ // down: lie along incline, slide, maybe get up
this.av*=1-4*h; this.a+=this.av*h;
if(this.a>A_HI){this.a=A_HI;this.av=0;}
if(this.a<A_LO){this.a=A_LO;this.av=0;}
this.t+=h;
if(this.crowd<=CROWD_MAX && Math.abs(this.vs)<40 && this.h<6) this.calm+=h; else this.calm=0;
if(this.calm>GETUP_DELAY && this.t>0.9) this.setState(3);
break;
}
case 3:{ // rising: kinematic scramble back to vertical
if(this.h>2.5){ this.setState(1); break; }
const prev=this.a;
this.a+=(this.a>0?-1:1)*RISE_RATE*h; this.av=0;
if(prev*this.a<=0) this.a=0;
this.t+=h;
if(Math.abs(Ax)>14) this.setState(1); // a fresh jerk knocks them down again
else if(this.a===0 && this.crowd<=CROWD_MAX) this.setState(0);
break;
}
}
this.av=clamp(this.av,-14,14); this.vs=clamp(this.vs,-420,420); this.vh=clamp(this.vh,-420,420);
if(!isFinite(this.a+this.s+this.h)){this.s=IM.L*0.5;this.h=0;this.a=0;this.av=0;this.vs=0;this.vh=0;this.setState(0);}
}
}
/* ---------- crowd ---------- */
const people=[];
(function(){ const lo=60, hi=IM.L*0.6;
for(let i=0;i<N;i++) people.push(new Person(lo+(hi-lo)*(i/(N-1))));
})();
/* ---------- escalator speed (fast reversal ramp) ---------- */
function updateEsc(h){
const dv=esc.target-esc.speed, maxDv=JERK*h;
const applied=clamp(dv,-maxDv,maxDv);
esc.speed+=applied; esc.accel=applied/h; esc.scroll+=esc.speed*h;
}
/* ---------- person vs person ---------- */
function resolveCollisions(){
for(const p of people){ p.crowd=0; p.circ=bodyCircles(p); }
const md=2*CR, md2=md*md;
for(let i=0;i<people.length;i++){
const A=people[i].circ;
for(let j=i+1;j<people.length;j++){
const B=people[j].circ; let touched=false;
for(let a=0;a<3;a++) for(let b=0;b<3;b++){
const dx=B[b].x-A[a].x, dy=B[b].y-A[a].y, d2=dx*dx+dy*dy;
if(d2<md2 && d2>1e-6){
const d=Math.sqrt(d2), nx=dx/d, ny=dy/d, c=(md-d)*0.5*CORR;
addBaseWorld(people[i],-nx*c,-ny*c);
addBaseWorld(people[j], nx*c, ny*c);
const vi=baseVelWorld(people[i]), vj=baseVelWorld(people[j]);
const vn=(vj.x-vi.x)*nx+(vj.y-vi.y)*ny;
if(vn<0){
const P=(1+REST_COL)*(-vn)*0.5;
setBaseVelWorld(people[i],vi.x-nx*P,vi.y-ny*P);
setBaseVelWorld(people[j],vj.x+nx*P,vj.y+ny*P);
const kn=clamp(-vn*KNOCK,-3,3); // off-centre hit -> spin -> topple
people[i].av+=kn; people[j].av-=kn;
}
touched=true;
}
}
if(touched){ people[i].crowd++; people[j].crowd++; }
}
}
}
function physicsStep(h){ updateEsc(h); for(const p of people) p.integrate(h); resolveCollisions(); }
/* ---------- rendering ---------- */
function drawEscalator(){
const P0=IM.P0,P1=IM.P1,dUp=IM.dUp,nrm=IM.nrm,L=IM.L;
const bh=46;
ctx.beginPath();
ctx.moveTo(P0.x,P0.y); ctx.lineTo(P1.x,P1.y);
ctx.lineTo(P1.x-nrm.x*bh,P1.y-nrm.y*bh); ctx.lineTo(P0.x-nrm.x*bh,P0.y-nrm.y*bh);
ctx.closePath(); ctx.fillStyle='#1d222b'; ctx.fill();
const STEP=30, riser=16;
const k0=Math.floor((-esc.scroll)/STEP)-1, k1=Math.ceil((L-esc.scroll)/STEP)+1;
for(let k=k0;k<=k1;k++){
const s0=k*STEP+esc.scroll; if(s0<-STEP||s0>L) continue;
const ax=P0.x+dUp.x*s0, ay=P0.y+dUp.y*s0, bx=P0.x+dUp.x*(s0+STEP), by=P0.y+dUp.y*(s0+STEP);
ctx.beginPath();
ctx.moveTo(ax,ay); ctx.lineTo(bx,by);
ctx.lineTo(bx-nrm.x*riser,by-nrm.y*riser); ctx.lineTo(ax-nrm.x*riser,ay-nrm.y*riser);
ctx.closePath(); ctx.fillStyle=(k&1)?'#3a4250':'#333a47'; ctx.fill();
}
ctx.strokeStyle='#4b5464'; ctx.lineWidth=2;
ctx.beginPath(); ctx.moveTo(P0.x,P0.y); ctx.lineTo(P1.x,P1.y); ctx.stroke();
const ro=54, ax=P0.x+nrm.x*ro, ay=P0.y+nrm.y*ro, bx=P1.x+nrm.x*ro, by=P1.y+nrm.y*ro;
ctx.beginPath();
ctx.moveTo(P0.x,P0.y); ctx.lineTo(P1.x,P1.y); ctx.lineTo(bx,by); ctx.lineTo(ax,ay); ctx.closePath();
ctx.fillStyle='rgba(120,150,185,0.05)'; ctx.fill();
const stress=clamp(Math.abs(esc.accel)/JERK,0,1);
ctx.strokeStyle='rgb('+Math.round(34+stress*190)+','+Math.round(38+stress*24)+','+Math.round(46+stress*24)+')';
ctx.lineWidth=7; ctx.lineCap='round';
ctx.beginPath(); ctx.moveTo(ax,ay); ctx.lineTo(bx,by); ctx.stroke();
ctx.strokeStyle='#3a4150'; ctx.lineWidth=2;
const TIE=26, j0=Math.floor((-esc.scroll)/TIE)-1, j1=Math.ceil((L-esc.scroll)/TIE)+1;
ctx.beginPath();
for(let j=j0;j<=j1;j++){
const d=j*TIE+esc.scroll; if(d<0||d>L) continue;
const px=ax+dUp.x*d, py=ay+dUp.y*d;
ctx.moveTo(px-nrm.x*4,py-nrm.y*4); ctx.lineTo(px+nrm.x*4,py+nrm.y*4);
}
ctx.stroke();
}
let nowT=0;
function drawPerson(p){
const b=baseWorld(p), ax=Math.sin(p.a), ay=-Math.cos(p.a), px=Math.cos(p.a), py=Math.sin(p.a), Hh=PH;
const col=p.state===0?'#79e0b8':p.state===1?'#ffb24d':p.state===2?'#ff5f56':'#ffe15a';
ctx.strokeStyle=col; ctx.fillStyle=col; ctx.lineWidth=2.6; ctx.lineCap='round'; ctx.lineJoin='round';
const hip={x:b.x+ax*Hh*0.44,y:b.y+ay*Hh*0.44};
const sho={x:b.x+ax*Hh*0.80,y:b.y+ay*Hh*0.80};
const head={x:b.x+ax*Hh*0.93,y:b.y+ay*Hh*0.93};
const fL={x:b.x+px*4.5,y:b.y+py*4.5}, fR={x:b.x-px*4.5,y:b.y-py*4.5};
ctx.beginPath();
ctx.moveTo(hip.x,hip.y); ctx.lineTo(fL.x,fL.y);
ctx.moveTo(hip.x,hip.y); ctx.lineTo(fR.x,fR.y);
ctx.moveTo(b.x,b.y); ctx.lineTo(sho.x,sho.y);
ctx.stroke();
const flail=clamp(Math.abs(p.av)*0.22+(p.state===0?0:0.95),0,1.7);
const sw=Math.sin(nowT*0.008+p.wob)*0.18, armLen=Hh*0.34;
const hand=(sign,ang)=>{const dx0=-ax,dy0=-ay,ca=Math.cos(sign*ang),sa=Math.sin(sign*ang);
return {x:sho.x+(dx0*ca-dy0*sa)*armLen, y:sho.y+(dx0*sa+dy0*ca)*armLen};};
const hL=hand(1,0.35+flail+sw), hR=hand(-1,0.35+flail-sw);
ctx.beginPath();
ctx.moveTo(sho.x,sho.y); ctx.lineTo(hL.x,hL.y);
ctx.moveTo(sho.x,sho.y); ctx.lineTo(hR.x,hR.y);
ctx.stroke();
ctx.beginPath(); ctx.arc(head.x,head.y,4.6,0,7); ctx.fill();
}
function drawHUD(){
const down=people.filter(p=>p.state===2).length;
const fall=people.filter(p=>p.state===1).length;
const up=people.filter(p=>p.state===0).length;
ctx.font='600 14px system-ui,sans-serif'; ctx.textBaseline='middle'; ctx.textAlign='left';
ctx.fillStyle='#8b97a8';
ctx.fillText('upright '+up+' falling '+fall+' down '+down+' / '+people.length,16,22);
ctx.fillStyle=esc.speed<-1?'#ff5f56':'#79e0b8';
const dir=esc.speed>1?'up':esc.speed<-1?'REVERSE':'stopped';
ctx.fillText((esc.speed<-1?'\u25BC ':esc.speed>1?'\u25B2 ':'\u25A0 ')+dir+' '+Math.abs(esc.speed).toFixed(0)+' px/s',16,44);
}
function render(){
ctx.fillStyle='#0e1117'; ctx.fillRect(0,0,W,H);
drawEscalator();
const order=people.slice().sort((a,b)=>a.h-b.h); // higher in the pile drawn on top
for(const p of order) drawPerson(p);
drawHUD();
}
/* ---------- main loop (fixed sub-steps) ---------- */
let last=performance.now(), acc=0; const H=1/120;
function loop(now){
nowT=now;
let dt=(now-last)/1000; last=now; if(dt>0.05)dt=0.05;
acc+=dt;
let steps=0;
while(acc>=H && steps<8){ physicsStep(H); acc-=H; steps++; }
if(steps>=8)acc=0;
render();
requestAnimationFrame(loop);
}
btn.addEventListener('click',()=>{
if(esc.target===VUP){ esc.target=VREV; btn.textContent='RESTORE'; btn.classList.add('rev'); }
else { esc.target=VUP; btn.textContent='REVERSE'; btn.classList.remove('rev'); }
});
requestAnimationFrame(loop);
})();
</script>
</body>
</html>
What it actually does
On load, 18 figures ride the incline upright, feet locked to the steps, each held vertical by its own balance controller. Press REVERSE and the step speed ramps from +24 to −150 px/s in about a third of a second. That ramp is the whole disaster: the base of every standing figure is yanked with the step, the horizontal base-acceleration term in the lean equation spikes to roughly three times what the ankle-torque clamp can answer, lean runs away past the commit angle, and essentially everyone topples (up-slope, i.e. they fall backward as the machine drops out from under them). There is no per-person fall trigger — they all read the same global esc.accel, so the near-simultaneous collapse is a consequence of the shared rule, not a script. Fallen bodies then slide down (gravity along the incline beats the velocity-proportional friction to the step), collide, shove, climb and heap against the bottom wall; a downed figure is a low wide capsule, so it blocks and trips the ones arriving behind it. Press RESTORE and the reverse jerk briefly re-drops anyone who had started to stand, then the survivors that have room and footing scramble up and ride back up.
Things I nudged or special-cased, honestly:
- Getting up is kinematic. A downed body can't torque itself up from flat (gravity beats any ankle torque at 90°), so
risingjust drives the lean angle back to vertical at a fixed rate once the figure is calm. It's the one behaviour that isn't real rigid-body dynamics. - Lean is 1-DOF. Each person is a pendulum pivoting at the feet, not a full free rigid body; the base doesn't have independent rotational inertia.
- Collisions are three circles per body, inelastic, with a small
av"knock" added on hard hits so pile-ups can topple bystanders. It's a heuristic, not a proper contact solve. - The reversal is a constant-jerk speed ramp (
JERK), which is what sets how violent the throw is.
What it does badly / what to watch for:
- I could not run it, so the constants are reasoned, not tuned. The topple may be too instant or too gentle; if nobody falls, raise
JERKor lowerAMAX; if they explode, lowerJERK/KNOCK. - Everyone falls the same way (the disturbance is uniform), so the first collapse looks choreographed even though it isn't. Variety only creeps in through collisions.
- The pile is soft — bodies overlap a little and may jitter under the positional correction; it reads as a heap, not a rigid stack.
- Downed bodies always end up at the bottom regardless of escalator direction (gravity along the 22° incline beats my friction), so recovery only happens from the bottom as the pile thins from the edges.
- Leave it running normally and people eventually pile at the top landing — there's no exit/respawn, by design, to keep the reversal the main event.
Attachments
baidu/ernie-5.5-flash-preview — page