A grid snake jumps one square per tick. Serpentine instead keeps the head at an exact position with a
direction, and moves it forward in small, equal steps. The game works out its physics exactly 60 times a
second, whatever your screen's refresh rate, by collecting the real time that has passed and spending
it in fixed slices of 1/60 of a second:
// from the game's source, with its comments trimmed
const FIXED_STEP_SEC = 1 / 60; // 0.016667s baseline
...
if (frameTime > 0.1) frameTime = 0.1;
s_accumulator += frameTime;
...
let maxSubSteps = 8;
while (s_accumulator >= FIXED_STEP_SEC && maxSubSteps > 0) {
update(FIXED_STEP_SEC);
s_accumulator -= FIXED_STEP_SEC;
maxSubSteps--;
}
Inside each step the head moves by speed × step time:
headPos.addScaledVector(headDir, currentSpeed * dt);
With a step of 1/60 s, a Medium snake at speed 10 moves 0.167 units per step - 10 units a second - and
crosses its 40-unit board in 4.0 seconds. On Hard, at speed 15, it is 0.25 units per step and 2.4
seconds from wall to wall. Because the step never changes, the game plays the same on a 60 Hz laptop
and a 144 Hz monitor. The 0.1-second cap and the limit of 8 steps a frame stop it racing to catch up
after you switch back from another tab.
Turning is smoothed too. The direction is blended a little towards the pointer each step with a
linear interpolation (lerp) and then rescaled to length 1, so the snake curves instead of
snapping.
Following the leader
The body is a list of points. After the head moves, each segment looks at the one in front of it; if
it has fallen more than one spacing behind, it is pulled forward along the line between them:
const dist = _segDiff.length();
if (dist > spacing) { _segDiff.normalize().multiplyScalar(dist - spacing); curr.sub(_segDiff); }
Nothing tells the body where to go. Each segment only chases its neighbour, and the whole snake
traces the path of the head - the same trick used for ropes, chains and trailing tails in many games.
