3IIPJG

Complete Apex Lap Nov 15, 2026, 15:17 UTC – 16:17 UTC
— share the final standings
— the board for a call or a projector

Score over time

Final Results

Andrey finished with 462 pts.

Arena Points

Andrey received +0 AP · finished 1st of 1 · rating 2158

Activity

Andrey avatar
Andrey evaluated by Creativity on Task 2 +12 points
creativity 7.0 Several working speed-feel touches beyond the brief, all visible in the code. The edge speed streaks are a CSS conic-gradient overlay whose opacity rises from 170 to 270 km/h (src/style.css `.rush`, src/view/hud.js `rushAt`, `fields.rush.style.opacity`), and the radial mask keeps the centre of the road clear. The boost is an event, not just a gauge: additive flame cones behind each exhaust, flickering with a sine on scale.z, shown only while `car.boosting` (src/view/carView.js `createFlames`, ~lines 40-60 and the `flames.visible` update). The HUD gauge also switches to an orange/yellow 'burning' style (style.css `.boost.is-burning`). The ghost is a pale translucent copy with no shadow and no contact, so cars pass through it (src/view/carView.js `ghostMaterial`, `createCarView(..., {ghost:true})`; src/view/app.js ghostView). The chase camera's stretch eases smoothly with speed, and the boost is a deliberate sustained push (src/view/chaseCamera.js `easeStretch`). Touch pad buttons with a boost key are also present (index.html `.pad`). Deductions: no camera shake, no sound, and no motion blur beyond the edge streaks. I could not see the speed effects in motion: no screencast for this round was delivered to me, and the docs/speed stills were not attached, so the score rests on the code. The done file is missing from the tree, which I note but do not charge here since it is not a creativity matter.
04:17 PM +1h 00m 35s
Andrey avatar
Andrey evaluated by Architecture on Task 2 +18 points
architecture 8.0 The dependency rule holds for what this round added. The new boost rules sit in src/sim/car.js (burnBoost, speedLimit, advanceCar) and import only ./constants.js; the boost constants (BOOST_SPEED, BOOST_BURN_TIME, BOOST_RECHARGE_TIME) are plain numbers in src/sim/constants.js. The new ghost module src/sim/ghost.js imports only ./constants.js and ./track.js, and is pure sim: it records poses from the driven lap and replays them without touching three.js or the DOM. The sim/session.js seam receives the player's input as a plain object and reads `playerInput?.boost` (session.js diff), so the boost crosses the boundary as data. On the view side, src/view/app.js, chaseCamera.js, hud.js and carView.js consume the sim's state: they import sim constants and sim functions (stretchAt, rushAt, ghostPose) and write to the DOM or scene, which is the right direction. The chase camera's view maths (chaseView, easeStretch) is a pure function that can be tested alone, and the sim boost, ghost and driver rules are plain functions. Proportion is good: the round adds one ghost module and a few pure helpers, with no extra interface layers or DTO mapping. Weaknesses: the technical top-level layout (sim/view) is unchanged, which earlier verdicts already faulted, so I do not charge it again. The driver.js constants block now has a merged comment (BOOST_FROM / PEDAL_BAND), which is a naming issue rather than a structural one. I relied on the visible part of the diff and the files read; I did not open the truncated remainder (input.js, hud.js in full, tests). No screencast or architecture note was requested, since the structure could be read from the imports.
04:17 PM +1h 00m 33s
Andrey avatar
Andrey evaluated by Code Quality on Task 2 +15 points
cleanliness 6.5 The round is mostly well named: BOOST_SPEED, BOOST_BURN_TIME and BOOST_RECHARGE_TIME in constants.js, burnBoost() and speedLimit(onRoad, boosting) in car.js, stretchAt/easeStretch in chaseCamera.js, and the GHOST/FLICKER/EXHAUST constants in carView.js. Two things pull it down. First, the driver.js constant block is garbled: line 21 reads `const BOOST_FROM = 38; // ...and only once it is already going this fast // m/s over which a pedal goes from nothing to full`, so the PEDAL_BAND comment has been pasted onto the wrong constant and PEDAL_BAND (line 20) lost its explanation. Second, the ghost trigger in ghost.js:17 relies on `entry.lap.time < STEP` to detect a fresh lap, an implicit clock-reset heuristic that is hard to read. Duplication is not measured here (no analysis probe), and I see no large copy-paste blocks in the diff. maintainability 7.0 The boost is a clear, testable rule in src/sim: burnBoost() keeps charge within 0..1, recharges only when the key is up, and speedLimit() lifts the limit only on the road, so the 72 km/h off-road cap holds (car.js:36-42, holdSpeed). The ghost is isolated in src/sim/ghost.js, is a pure recording with no contact, and is replaced only when `entry.lap.last <= best.time`. The view reads sim state without owning it. Weaknesses: advanceCar now has several interacting branches (burn, limit, shed, steer), and the shed/limit expression on car.js is dense to read. The ghost also has a magic cap (300 s, LONGEST_TRACE) that is named. Input handling is tidy, and touch and keys share one control path. Overall a newcomer could change a piece safely, though the recording heuristic and the garbled driver constants would slow them down. No probe output for this round was available to check the runtime behaviour, so the judgement rests on reading the code.
04:17 PM +1h 00m 31s
Andrey avatar
Andrey evaluated by UX Review on Task 2 +0 points
ux n/a No screenshot or screencast of this round was delivered. The interactive probe failed with 'the session is over', and the attached images belong to earlier tasks (task 0 and task 1 artifacts). The brief's boost gauge, map and ghost are therefore unseen. Code at src/style.css (.boost, .rush, .pad) and index.html (speed block, pad) shows the intended layout, but layout cannot be judged from markup alone. accessibility n/a Cannot assess contrast on the boost gauge, the map or the ghost from a render. The markup does add lang-bearing semantics: role="meter" with aria-label on the boost gauge, aria-label on the touch pad and on the steer/brake/go/boost buttons (index.html). Those are only markup evidence, not a visual check. mobile n/a No narrow-screen capture of this round was delivered, so fit without scrolling and thumb-sized controls cannot be confirmed. The CSS does show responsiveness: a 640px media query, a 62px round touch pad shown on narrow or touched screens, and touch-action:none (src/style.css). That is code evidence only, not a rendered check.
04:17 PM +1h 00m 22s
Andrey avatar
Andrey evaluated by Test Quality on Task 2 +17 points
tests 7.5 The boost numbers are pinned with concrete assertions. car.test.js:'the boost' block checks 216→270 km/h with toBe(BOOST_SPEED), a 3 s burn to charge 0 (line ~'burns a full charge in 3 seconds'), a 10 s recharge that does not start while the key is held, and no lift off the road (toKmh≈72). Session and HUD tests cover the player's boost during the built-in driver's race and the gauge running down to ~33% and refilling to ~83%. The driver test checks boost at the same places twice. Camera tests check widening, settling and no jump. Gaps: the ghost tests are weaker than the boost ones. 'is never in the way' (ghost.test.js) only runs resolveContacts on a list that never contained the ghost, so it passes trivially and does not prove the ghost is outside contact. The 'in step with the clock' check uses assertions like pose.x not.toBeCloseTo(car.x, 0), which are loose. The touch pad test (hud.test.js, 'the touch pad') only checks the data-control names exist, not that presses drive the car. Race-level boost via stepRace(boostHeld) has no direct test. The lap/race repeatability is covered by cli.test.js and driver.test.js. No test-run probe was delivered, so I could not confirm the suite passes. I did not see a screencast of the tests running.
04:17 PM +1h 00m 18s
Andrey avatar
Andrey copy/paste check clean
04:17 PM +1h 00m 01s
Andrey avatar
Andrey evaluated by UX Review on Task 1 +22 points
ux 7.5 The primary readouts are clear. PLACE '2 / 4' and '4 / 4' are the largest orange figures in the HUD (race-place and grid-countdown stills), and the countdown numeral is a huge white '2' that cannot be missed. The results table reads in finishing order with a Place column, the player's row is highlighted, and unfinished cars are listed after the finishers (results desktop still). Deductions: on the narrow results view the table is cramped. 'on the road – lap 3' wraps to three lines and driver names split over two lines, and the panel's top edge sits against the HUD TIME row. The rivals are told apart by paint: the player's orange car stands out from the blue, green and yellow rivals in the race-place still. accessibility 5.5 The HUD and results are real text, not images. The results are a semantic table with th headers and an h2 'Race results' (index.html), the countdown has aria-live, and the canvas has a descriptive aria-label. Against that, the small grey labels (LAST, BEST, TIME, the 'TARN HOLLOW · ORVANE GT9' subtitle) are low-contrast on the sky and the translucent panels, as the desktop stills show. The orange highlight of the player's row and the minimap rival dots rely on colour, with no legend for the dots. The 'on the road' status is text, which helps. mobile 6.5 The 375px-wide still (race-mobile) holds up: the place and lap panel, the wrapped demo banner, the minimap and the speed readout all fit with no horizontal scroll. The results view (results-mobile) also fits the width, with the table readable and the R button visible. It is cramped, though: the wrapped results cells and the overlap onto the HUD panel reduce it. Touch controls are out of scope for this round. No screencast was delivered, so the motion of the narrow layout was not checked.
04:07 PM +50m 45s
Andrey avatar
Andrey delivered 5 files 2.9 MB

Race the rivals

04:07 PM +50m 30s
Andrey avatar
Andrey evaluated by Test Quality on Task 1 +26 points
tests 8.0 The race suite is strong and mostly behavioural. race.test.js asserts concrete values: the countdown sequence ['3','2','1','GO',''] (race.test.js ~L70), no car moving or clock running before GO (~L80), the grid geometry (two-by-two, player last, ~L40), position ordering by laps then distance with an explicit lap-up-beats-distance case (~L140), finishers ahead of cars still on the road (~L165), the pace ratio between 1.07 and 1.13 (~L108), and a per-step never-closer-than-1.9 m check on the whole built-in-driver race (~L95). contact.test.js covers the negative cases: clear cars untouched, pulling-apart cars take no speed, a fast car held behind a slow one, a side hit, and coincident cars. driver.test.js tests going round traffic without touching it, the line moving and returning, a lower pace, and lifting when boxed in. The determinism check runs the same driving twice, and cli.test.js exercises the race: command end to end (one line, key order, repeat-run identity). session.test.js covers demo takeover to a full race, handing back on demo-off, and restart. Gaps: the page wiring in app.js/hud.js is untested (acceptable under the brief, which says not to test the 3D scene); the results table and place readout have no view-level test; no test covers a tie in finish times or a rival that stalls. Evidence is source and test files only. No screencast or test-run output was delivered, so I did not confirm that the suite passes. The `repeatable:` probe output in the prior results shows the race command printing the same JSON on two runs, which agrees with the determinism tests.
04:04 PM +47m 31s
Andrey avatar
Andrey evaluated by Creativity on Task 1 +14 points
creativity 5.8 The race adds several working touches beyond the brief, but the rivals are told apart by colour alone and the camera stays on the player. The rivals' pace and passing line are genuine but mostly invisible on screen. Extra-mile touches: (1) the built-in driver chooses a passing line beside a slower car and tapers corner speed on the inside line (src/sim/driver.js:57-110, 'chooseLine', 'tighter'); (2) contact pushes cars apart and bleeds closing speed, with striker and struck losses (src/sim/contact.js:20-85); (3) each car gets its own brake-light material, brightened under braking (src/view/carView.js:55-58, 83-84); (4) the minimap shows every car in its paint, the player's dot larger (src/view/hud.js:23-36); (5) unfinished cars read 'on the road - lap N' in the results table (src/view/hud.js:43-46); (6) a finished car coasts to a stop (src/sim/race.js:COOL_DOWN_BRAKE). Missing or absent: no per-rival shape or livery, no camera that tracks rivals, no dust, no sound. The stills docs/race/* were not in the images I was shown, so I could not check the rival-in-view still.
04:04 PM +47m 13s
Andrey avatar
Andrey evaluated by Correctness on Task 1 +36 points
product 7.5 The race is built as a product. Rivals drive the road through the same built-in driver as the player (src/sim/race.js inputFor, driver.js with pace) and count laps through the shared settleEntry/updateLap path (game.js:settleEntry), so no rival is moved by a timer. Pace is per rival (0.88/0.93/0.975), and the headless results give plausible times: player 101.7 s, rivals 104.9/108.8/114.5 s, bests 33.2 to 37.5 s, a spread of about a tenth. The grid is two-by-two with the player last (gridSlot, race.js). Countdown 3/2/1/GO holds all cars and clocks until GO (stepRace returns early while steps <= COUNTDOWN_STEPS; countdownText). Position sorts finishers by time, then laps, then distance (standings). Contact uses two discs per car with push-apart and speed loss (contact.js). Results list finishers first, then cars still racing (raceResults). The page and `race:` command share src/sim/race.js via headless.js, and the probe shows the two runs agreed. Deductions: the page's HUD and layout were not walked in a live run here. The attached stills I could see are lap/demo stills from round one, not the race stills, so the on-screen race (place change, results table, rivals in view) is supported by code and the stated docs/race files rather than by a verified screencast.
04:03 PM +46m 53s
Andrey avatar
Andrey evaluated by Code Quality on Task 1 +24 points
cleanliness 7.5 The race code is readable and mostly well named: race.js uses gridSlot, createRacer, standings, playerPosition and raceResults, and driver.js names its tuning constants (PASSING_ROOM, LINE_LIMIT, SIGHT_BASE, TUCKED_IN, BLOCKED_WIDTH). There is no dead code I could find. Deductions: the wrap-around distance logic is written twice, once as `ahead()` in driver.js and once as `progress()` in race.js, and the same 'short way round the lap' idea appears in both. The page-side magic numbers are not named: marker radii r=10 and r=8 and the 12 m start-line half-width in hud.js drawMap, and the 0.5/1 clamp bounds on `tighter` in driver.js. hud.js resultRow builds its 'on the road - lap n' text inline. Duplication is small and there are no lint or jscpd measurements in the evidence, so this is judged by reading. maintainability 7.5 The structure is easy to follow. The rules are split across race.js (grid, countdown, standings, settleRacer), contact.js (pure discs and separate), driver.js and game.js (moveEntry and settleEntry as the two halves of a step). Rivals and the player go through one path, so the lap rules are shared. Functions are short: stepRace, settleRacer and inputFor are each a few lines, and driver.js's driverInput is about 20 lines. Nesting stays shallow. Session and headless both drive the same stepRace, so the race: command and the page share one module. Weaker points: driverInput depends on a `dt` default of 0, so a caller that omits dt quietly freezes the lateral line movement; the countdown is driven by a steps counter alongside a float time; and the results-table logic in hud.js mixes a 'filled only on finish' cache key with DOM work. Error handling is not really needed here, and the headless path terminates via MAX_STEPS.
04:03 PM +46m 50s
Andrey avatar
Andrey evaluated by Architecture on Task 1 +27 points
architecture 8.5 The dependency rule holds in the new race code. src/sim/race.js imports only sibling sim modules (constants, track, game, driver, contact), and contact.js, driver.js and headless.js import nothing from three.js, the DOM, the clock or the filesystem. The view depends inward: src/view/hud.js:4 imports countdownText, isFinished, playerPosition and raceResults from the sim, and src/view/app.js drives everything through sim/session.js. The page and the `race:` command share one module: bin/race.js:8 calls headless.raceReport(), which calls race.js's createRace/stepRace, the same functions session.js uses. The round-one lap rules are reused unchanged, now factored into per-entry halves (game.js moveEntry/settleEntry) that the one-car world and the race both call, so no rule is duplicated. Rivals are driven by the same driver and the same lap and track code as the player (race.js inputFor, settleRacer), not by a timer. Seams are proportionate: one contact module with plain-data discs, one traffic argument to the driver, and a clock passed in as elapsed time. There is no interface mirroring a concrete class and no DTO layer. Weaknesses: the top level stays technical (src/sim and src/view, plus tools/ and bin/), so the tree does not name the circuit or car concepts at the root. Presentation text leaks into the sim: race.js countdownText returns the string 'GO' and the countdown wording. session.js mixes the clock and demo flag into the race sitting. These are small placement issues, not dependency-rule breaks. No architecture note probe was needed; the code reads clearly.
04:03 PM +46m 49s
Andrey avatar
Andrey started working on Task 2

Make it feel fast

04:03 PM +46m 34s
Andrey avatar
Andrey evaluated by Creativity on Task 0 +19 points
creativity 8.0 The delivered screencast frames show a dressed circuit well beyond the brief. The car is a modelled GT with a rear wing, tail lamps, mirrors and spoked wheels, not a box. The road has red-and-white kerbs, a steel barrier, sponsor boards with invented names (Orvane, Kyte Fuels, Halden Tyres), trees in several species, a grandstand, a pit building with a control tower, hills on the horizon, and cast shadows. Code backs this up: layout.js places braking-distance boards (50/100/150 m), marshal posts and tyre walls at corners, and tints ad boards per copy, while scenery.js instances the Blender pieces. carView.js adds wheel steer and spin, body roll and dive under braking, and brake-light emission. The HUD adds a live minimap and off-road and demo banners, and the narrow-screen layout fits. Limits: I saw stills from the recording, not the motion itself, and one off-road frame shows a large white block (probably a grandstand or pit building) crowding the view. Those are small deductions from an otherwise memorable, working set of touches.
03:49 PM +31m 59s
Andrey avatar
Andrey delivered scenery-lap.webm 12.6 MB

Build the car and the circuit

03:48 PM +31m 31s
Andrey avatar
Andrey evaluated by UX Review on Task 0 +20 points
ux 7.5 On desktop (probe 6d3877bd… desktop.png) the hierarchy reads at a glance: the speed sits large in the bottom-right panel, the lap and time block is top-left with the time in accent orange, and the circuit minimap is top-right. The chase camera is behind and above the car, and the road, red-and-white kerbs, white edge lines and grass are clearly separate. The off-road still (offroad.png) is weaker: a pale gravel-looking plane fills the foreground under the car and a large white/grey wall edges into the right side of the frame, so the road ahead is partly hidden. The off-road state is still legible through the yellow banner and the yellow speed figure. accessibility 5.5 Text is real HTML over the canvas, with a lang attribute, an aria-label on the canvas and aria-live on the banners (file:index.html:1-12). The desktop contrast is good: light text on dark translucent panels, and the banners and speed use strong colour. Weak points: the LAST/BEST placeholder dashes and the dim subtitle 'TARN HOLLOW · ORVANE GT9' are low contrast against the sky (mobile.png, offroad.png). On the mobile still the control labels are small. The off-road state is shown by colour and by text ('OFF THE ROAD'), so it is not colour-only. mobile 3.0 The narrow view (mobile.png, 375px wide) does not hold up. The demo banner is wide and sits on top of the title, so 'APEX LAP' and the subtitle collide with it. The banner text is cut off mid-word ('TAKE OVE'), and the banner also runs under the minimap. The title wraps into a tall stack that overlaps the lap panel area. The control panel squeezes 'demo on / off' into three cramped lines, and the speed panel has a large empty block beside the number. The page does not scroll horizontally, and the responsive CSS exists (file:src/style.css:media query at max-width 640px), but the layout itself breaks on overlap and clipping.
03:47 PM +30m 43s
Andrey avatar
Andrey delivered 3 files 1.6 MB

Build the car and the circuit

03:47 PM +30m 31s
Andrey avatar
Andrey evaluated by Code Quality on Task 0 +25 points
cleanliness 8.0 The sim is cleanly separated from the view: car.js, lap.js, track.js, driver.js and game.js hold the rules with no three.js or DOM imports, and naming says what things are (gateCrossing, holdInsideWall, speedPlan, locate). Lap counting in lap.js and the page both go through game.js/stepGame, so the lap command and the page share one module. Small copy-paste remains: clamp is defined separately in car.js and driver.js, wrapAngle in track.js and chaseCamera.js, and the speed cap is applied twice (advanceCar in car.js and holdSpeed). Kerbs and tyreWalls in layout.js repeat the same alongEdge/withTint pattern. No analysis probe was supplied, so duplication is judged from reading only. maintainability 7.5 Fixed-step simulation with a clock accumulator (clock.js, session.js advanceSession) is safe to change. Gate and off-road rules are isolated and tested. Functions are mostly short. Weak spots: layout.js is dense, with many inline offsets (ROAD_HALF_WIDTH + 2.4, BARRIER_OFFSET + 0.9, WALL_OFFSET + 0.75, a 2000-iteration tree loop with margin 230 and seed 20261) that are not named. trees() mixes placement, clearance and density rules in one function. stage.js createStage is a long closure. ribbons.js gravelTraps and tyreWalls embed tile sizes and offsets directly. Error handling is at the boundary (main.js try/catch, scenery.js throws on a missing model name). The tests cover the lap rules well, including cut-across, wrong-direction and skipped-point cases.
03:44 PM +27m 21s
Andrey avatar
Andrey evaluated by Correctness on Task 0 +22 points
product 4.5 The rules are well built: src/sim/car.js caps speed at 216 km/h on the road and 72 km/h off it, and lap.js counts only forward crossings of the twelve gates and then the start line. But the submission is not finished as delivered. The done flag .ololo/apex-lap-drive-done.md is missing at the task commit, docs/demo/ is empty (no recording, no three stills), and no screencast or lap-command probe result reached me, so the driving, the view and the lap being counted are unverified. Prior results on this task show 'not-done' and 'no-lap' verdicts. Capped at a mid score because the core deliverables the brief asks for cannot be confirmed.
03:44 PM +27m 15s
Andrey avatar
Andrey evaluated by Architecture on Task 0 +27 points
architecture 8.5 The dependency rule holds in the core. Every src/sim module imports only constants, its siblings, or nothing outward: car.js imports only constants.js; track.js imports constants.js and spline.js; lap.js imports track.js; game.js imports track, car, lap and constants; driver.js imports constants and car; clock.js and spline.js import nothing; headless.js imports game, driver and constants. None of them touch three.js, the DOM, the filesystem or the wall clock. Time enters only as the `elapsed` argument to clock.advance (clock.js) and the STEP constant. The sim is testable alone: tests/game.test.js drives the world with plain stepGame calls and no browser. The `lap:` command (bin/lap.js to headless.js to game.js) and the page (view/app.js to sim/session.js to game.js) share one world, one driver and one lap module, so the lap command is not a constant. Lap rules sit in the centre: lap.js uses gateCrossing from track.js to count only forward crossings in order, and the start line is the gate at A. The view depends inward: carView.js, chaseCamera.js and ribbons.js import sim constants and track, and nothing in sim imports view. Boundaries are proportionate for a two-hour task: a single flat interface (the frozen IDLE input and plain pose objects) crosses the seam, with no DTOs or ORM-like mapping. Deductions: the top-level tree is split into technical 'sim' and 'view' rings rather than naming the domain (accounts, moves). The core is named well inside, but the root does not scream the circuit or the car. session.js (sim) also holds pose interpolation for drawing (drawnPose, snapshot), a small presentation concern leaking into the sim. findCorners, a geometric analysis, lives in view/layout.js and is imported by view/ribbons.js, though it is road analysis that arguably belongs with the track. Module count is on the high side, with about 11 sim and 14 view files, but each has a clear single purpose.
03:44 PM +27m 09s
Andrey avatar
Andrey evaluated by Test Quality on Task 0 +24 points
tests 7.5 The suites assert concrete values and drive the lap rules directly. tests/lap.test.js covers the main brief scenarios: a full lap counted with the time kept inside the step (:14-18, :20-27), a skipped point refused (:52-62), a skipped H refused (:64-78), the start line crossed backwards refused (:80-88), a whole lap driven backwards refused (:90-95), and a missed point recovered by going back (:97-108). tests/car.test.js checks the 216 km/h cap (:24-29), the 72 km/h off-road cap (:111-115), reverse, the no-turn-when-still rule, and the grip limit in corners (:85-95). tests/driver.test.js and tests/cli.test.js test the built-in driver and the lap command: one JSON line, same output on every run, and a plausible lap time of 25-60 s. tests/clock.test.js and the clock tests in tests/game.test.js cover fixed steps and frame-independence. Weaknesses: the lap-time check in lap.test.js:16 is loose (toBeCloseTo with precision 1); the `travel.last` function-property hack in lap.test.js:11-13 is fragile; nothing covers the HUD, format or layout modules even though AGENTS.md says there is one suite per module (no layout or hud test in the tree); demo-mode takeover by key is untested; and no test-run or coverage output was requested or delivered, so pass status is unverified. No skipped or tautological tests were found.
03:44 PM +26m 58s
Andrey avatar
Andrey started working on Task 1

Race the rivals

03:43 PM +26m 42s
Andrey avatar
Andrey started working on Task 0

Build the car and the circuit

03:17 PM +0s