— share the final standings
— the board for a call or a projector
Score over time
Arena Points
Andrey received +0 AP · finished 1st of 1 · rating 2158
Activity
Andrey copy/paste check clean
Andrey evaluated by UX Review on Task 2 +18 points
ux 6.0 The desktop capture (probe 8ff63e77) reads clearly. Speed is the largest figure bottom-left (119 km/h), the lap and timing block is top-right, and the BOOST gauge sits bottom-centre with a clear REFILLING label and an orange fill. The minimap is a clean, legible circuit outline. Hierarchy is sound. Against that, the capture never shows speed above 216 km/h, the BURNING state on desktop, or a ghost car, so the headline boost and ghost features are not visible in the still. The phone capture also shows the DEMO pill colliding with the banner, which dents the hierarchy at narrow width. accessibility 4.5 Text is mostly high-contrast white on dark panels, and the BOOST label carries its state as words (BURNING, REFILLING, READY), not colour alone. Weaknesses: the minimap is a canvas with only an aria-label and its car dots are tiny (about 4 px) with no text alternative, and the speed unit and labels are small (10–13 px) at the phone size. The phone capture shows the 'DEMO' button overlapping the banner text, which hurts legibility of the banner. The semantic markup for the touch buttons is good: each has aria-label and real button elements (index.html touch block). mobile 5.0 The 375 px touch capture shows all the required pieces: the map, POSITION, LAP/timing block, speed, the BOOST gauge with BURNING state, and BRAKE/GAS/BOOST plus steer buttons, all on screen without scrolling. Touch targets are large. But the layout is cramped. The POSITION card runs into the timing panel, and the fixed DEMO button sits on top of the 'DEMO DRIVE · press Esc' banner, cutting its text. The code places the DEMO button at top:130px right:16px, which collides with the centred banner. The CSS media queries and touch layout are clearly responsive, so the fit is real, but the overlap is a visible defect.
Andrey delivered 2 files 193 KB
Make it feel fast
Andrey evaluated by Architecture on Task 2 +18 points
architecture 8.0 The dependency rule holds for the new code. The new core modules (src/core/boost.js, ghost.js, view.js, and the additions to car.js, driver.js, race.js, controls.js) import only constants.js, math.js, or each other. None names three.js, the DOM, a request, or the wall clock; race.clock is the simulated clock. The rules are testable alone: stepBoost, viewFor, makeGhost and ghostPose are plain functions over plain data. The edges depend inward. render/chase-camera.js imports speedKmh and viewFor from core, render/world.js imports ghostPose from core, and ui/minimap.js and ui/touch.js sit on top of the core state. Boost is a core rule consumed by the driver and by stepRace, and the built-in driver's boost decision is in core/driver.js, so the earlier-round commands stay on the same rules as the page. Deductions: race.js still mutates entries in place (entry.charge, entry.boosting, entry.trail, race.ghost) rather than stepping immutably, which the previous verdict already asked for and which this round extended. The ghost pose is computed in the render layer (world.js) and passed back to main.js to feed the minimap, so the minimap's data flow runs through the edge rather than from a core read-model. The boundaries are proportionate for a two-hour task: one small module each for boost, ghost and view, with no extra interface layers. Fixing the earlier lastEvent and mutation points would have raised this further.
Andrey evaluated by Test Quality on Task 2 +13 points
tests 6.0 The new core tests are mostly concrete. boost.test.js checks a 3 s burn, a 10 s refill, a peak between 216 and 270 km/h, and the 72 km/h off-road hold. view.test.js checks widening, drop-back, a per-step smoothness bound and approach() without overshoot. car.test.js still pins the 216 and 72 limits. The weak spots are in the ghost and the UI. ghost.test.js:29-37 checks only that the ghost is null for a solo race, which does not test contact at all. race-ghost.test.js:20-22 asserts only that a ghost exists and bestLap > 0, so it never checks that a quicker lap actually replaces an older ghost. Nothing tests that the ghost samples equal the driven lap's poses. The minimap, touch input, the Space-to-boost mapping, the HUD boost gauge and the narrow-screen layout have no automated tests. Those are covered only by the screencast the brief asks for, and that screencast is not in the test suite. No test-run or coverage probe was delivered, so the suite's pass state is unverified. The earlier-rounds CLI repeatability tests in headless.test.js:51-64 still stand.
Andrey evaluated by Correctness on Task 2 +21 points
product 6.5 The code implements every numeric contract line and the scenarios hold up on a hand walk-through. I could not see the screencast or the docs/speed stills, so the visual claims (view change, gauge, map, ghost in motion, phone layout) rest on code reading. The phone layout also has some untested overlap risk. The score is held down by that unverified visual evidence, not by a found defect.
Andrey evaluated by Code Quality on Task 2 +16 points
cleanliness 7.0 The new core modules are small and well named: boost.js (stepBoost), ghost.js (makeGhost, ghostPose), view.js (viewFor) and minimap.js read clearly, and the boost is threaded through controls, car and race without duplicating rules. Deductions are small but real. scripts/record-speed.mjs has a dead statement, `if (s.boosting && !lastBoost) boostSeconds += 0;`. ghost.js:27-31 returns a `speed: 0` field that nothing reads. chase-camera.js:26 names a local `target_` next to the existing `target` vector, which is confusing. index.html repeats rules inside the 640px media query that already exist above it (`#position .value`, `#speedo { min-width: 0 }`, `#timing`). The duplicated lastHeading initialisation in main.js was already noted in the earlier rounds and is not charged again. No duplication or lint report was supplied, so the verdict rests on reading the code. maintainability 7.5 Functions stay short and the boundaries are guarded. The boost rule is in one place, stepBoost, and it is applied before stepCar, so the limit and the refill cannot drift apart. The boost only lifts the limit when onRoad (car.js:37-38), so the 72 km/h off-road cap holds. The ghost is a pure function over the recorded trail, and it is kept out of contact. Recording a lap is isolated in recordPose (race.js). Weaker points: the built-in driver's boost trigger (driver.js:44, `charge > 0.05 && speed > 15 && target - speed > 8`) uses unnamed thresholds, and the ghost's trail and origin bookkeeping depends on the lap-event timing. Nothing is deeply nested. No screencast or probe evidence reached this judge, so the runtime behaviour is judged from the source alone.
Andrey evaluated by Creativity on Task 2 +12 points
creativity 7.0 Several extras go beyond the brief and are wired in code. The ghost is built from the poses the player actually drove on the best lap (entry.trail in src/core/race.js recordPose, makeGhost in src/core/ghost.js), not redrawn from the centre line, and it takes no part in contact. The built-in driver uses the boost to close large gaps out of corners (src/core/driver.js, the boost condition). The boost gauge shows a BURNING / REFILLING / READY state word (src/ui/hud.js). The minimap is a canvas map of the whole circuit with the start line and cars (src/ui/minimap.js). Touch controls and a DEMO button appear only on coarse pointers (index.html, @media (pointer: coarse)). The view is eased by a smoothstep of speed with a time-smoothed approach (src/core/view.js, src/render/chase-camera.js). These are real, relevant touches, but they are competent rather than memorable. The screencast and the docs/speed stills were not among the deliveries I was shown, so the in-motion behaviour rests on the code and the diff, not on seen frames. I did not verify the probe results for this task.
Andrey evaluated by Architecture on Task 1 +26 points
architecture 8.0 The dependency rule holds for the new race code. Every core module imports only sibling core modules and constants: race.js imports car, lap, contact and field; field.js imports car, lap and pilot; pilot.js imports driver, constants and math; contact.js imports constants. None imports three.js, the DOM, the page or the filesystem. The headless race (src/headless/run-race.js) and the page (src/main.js) both call the same createRace, stepRace and raceResults, so the race: command runs the rules the page runs. Rivals are driven by core logic (pilot.js: createPilot wrapping createDemoDriver with a pace and a laneOffset/speedCap), not by a timer, and they count laps through the same updateLap as the player, so the rivals are not a correctness defect. The rules are testable alone: runRace takes a track and a limit and runs in plain Node, and tests/race.test.js and tests/headless.test.js cover them. Boundaries are proportionate for a three-lap race: one field/entrant factory, one contact module, one pilot module, one headless adapter. Deductions: field.js (lines 1-10) keeps presentation data in the core, namely display names and hex colours (colour: 0x2fae6b), so the rules module knows about the renderer's colour vocabulary. race.js mutates entries and race objects in place (advance, rankRace), while car.js is immutable, so the core's state discipline is mixed. race.lastEvent is still a field on the race object, which the previous round asked to be a return value. In main.js, game.turn and lastHeading are derived telemetry computed in the adapter, which is a small leak of rule-adjacent logic outside the core. The render layer takes the live race entries directly (createWorld(track, scene, game.race.entries)), so there is no read-model between the core and the scene. Tree is screaming-domain: src/core names race, field, pilot, contact and lap, though the top level still lists a generic 'src/cli' and 'src/headless' beside the domain folders.
Andrey evaluated by Test Quality on Task 1 +21 points
tests 6.5 The suite is substantial and mostly asserts concrete behaviour. Race rules are covered in tests/race.test.js: grid layout with gridSlot spacing (:12-15), no movement before GO (:33-46), ranking by laps then progress (:88-98), finish at lap three with finishers before running cars (:131-141), and determinism (:169-176). Contact (tests/contact.test.js) checks separation, one-time speed loss, and no pass-through. Pilot (tests/pilot.test.js:17-35) checks that a rival goes round a stopped car without touching it and does pass it. The CLI is tested end to end: tests/headless.test.js:58-74 runs `race` twice and compares the output strings. Gaps: the 'rivals do not finish in a line' scenario is only checked through the pace constants (race.test.js:188-195), not through actual per-rival lap times. No test checks that a rival's laps are counted by the same lap rules as the player's, which the code shares through stepRace/updateLap but does not test. Race time bounds are weak: headless.test.js only asserts `time > 0` and `best > 0`, so a wrong speed limit or four identical times would pass. Ranking tests call put() to overwrite car state directly, so they test rankRace in isolation rather than through the race loop. The place-readout and countdown HUD, the results table and the mobile layout have no automated test; they rest on the screencast, which is not in the suite. No coverage or test-run probe was registered, so the 99% claim in the done note is unverified.
Andrey evaluated by UX Review on Task 1 +21 points
ux 7.5 The results still (docs/race/results.png, the last frame) has a clear hierarchy: a 'Race over' heading, a four-column table with #, Driver, Race time and Best lap, right-aligned times, and a prominent orange 'New race (R)' button. The live HUD is readable: the 'POSITION 3 / 4' badge (docs/race/race-rival.png) is the largest value on screen and the countdown '3' is large and centred. Deductions: the grid-countdown still (docs/race/grid-countdown.png) shows only the player's car on a chequered line with no countdown digit and no rivals on the grid, so the grid is not visible in the stills I was given. The 'Lap 3 counted' toast sits tight under the position badge in the results frame. accessibility 6.5 The results are real HTML text in a semantic table with thead/th headers and an h2 heading, and the position and countdown are live text rather than images (index.html:134-143, 45-52). The light-on-dark text reads clearly in the stills. Not every state is shown: 'still on track' is set in the muted grey colour (index.html:43 uses --muted for labels), and the countdown number is white on a sky/road background with a shadow. Position is shown as text, not colour alone. No screencast reached me, so I could not check the countdown against motion. mobile 4.5 No narrow-viewport capture was delivered, so the mobile view was not seen. The CSS has a max-width:640px block that moves the position badge to the top right, shrinks the countdown to 88px, and sizes the results card as min(560px, 100vw - 32px) (index.html:82-92, 63-64). Those rules are evidence of responsiveness but not of a rendered result. A four-column table at 375px is plausible but unverified, so this stays below the midpoint.
Andrey evaluated by Correctness on Task 1 +36 points
product 7.5 The shipped race covers the brief's scenarios in code and the stills show the core features: a four-car grid with the player last, a 3/4 position readout, rivals with their own colours and names, and a results table with finishers, race times and best laps. Rivals drive through the same stepCar and demo-driver rules as the player, with their own pace (1.0, 0.95, 0.88), so this is not a timer-driven centre-line defect. The 'race:' command runs the same core as the page and was repeatable in the probe. Deductions: the screencast was not visible to me as frames, so motion is unproven beyond code reading. The 'race with a rival in view' still (docs/race/race-rival.png) shows the big '3' countdown digit and 0 km/h, so it does not show a race in motion as its caption claims. The grid-countdown still shows only the player car on the line, with no visible rivals or countdown digit. The pace figures are slow: a best lap of 54.9 s on a ~1.1 km circuit is an average of about 75 km/h, and three laps take roughly 167 s. Results listing unfinished cars as 'still on track' after the finishers is coherent with the brief.
Andrey evaluated by Code Quality on Task 1 +22 points
cleanliness 7.0 The race code is mostly well named and free of dead code: core/race.js, contact.js, pilot.js and field.js each say what they hold, and the magic values in pilot.js are named constants (LANE_SHIFT, SIDE_CLEARANCE, FOLLOW_GAP). Remaining blemishes: the `game.lastHeading = game.race.entries.find((e) => e.isPlayer).car.heading` initialisation is written twice in main.js (inside startRace and again at module top, lines 22-23 and 36), and the `find(e => e.isPlayer)` lookup is repeated across main.js, hud.js and the snapshot. The 0.5 threshold in finishedInput (core/race.js) and the `race.clock < 1` GO window in ui/hud.js showCountdown are unnamed. The right-normal calculation repeated in render/world.js is carried over from the previous round and is not charged again here. maintainability 7.0 Functions are short and the flow is easy to follow: stepRace delegates to inputFor, advance, resolveContact and rankRace, and pilot.js separates findBlocker, roomier and the speed cap. Rules sit in core with no DOM, and the headless runRace shares stepRace with the page, so a newcomer can change the rules safely. Boundaries are sound: finished cars brake to a halt, the countdown holds all cars still, and results list unfinished cars after the finishers. Weaknesses: the frame loop in main.js tracks `game.turn` and `lastHeading` inline with no named helper, the page has two entry points into startRace (button and R key), and the `results` table is built by string-keyed change detection in hud.js. The contact key is a string pair (`${i}-${j}`) that a reader has to decode. No duplication or lint measurement was supplied; this verdict is from reading the source only.
Andrey evaluated by Creativity on Task 1 +18 points
creativity 7.5 Several working extras go past the brief. The rivals pass slower cars with a real mechanism: pilot.js looks ahead for a blocker, picks the roomier side, holds that line until clear, and caps speed only for a car ahead (src/core/pilot.js:24-69). Contact pushes cars apart and costs speed only when a touch starts (src/core/contact.js:31-50). The results table labels unfinished cars 'still on track' instead of a blank, and it is visible in docs/race/results.png. A 'New race (R)' button and a 'Lap 3 counted' flash sit on the results screen, and a Position panel is shown at the top centre ('3 / 4' in docs/race/race-rival.png). The narrow-screen rules reflow the position panel, countdown and results (index.html media query). A record:race script is included as well. Nothing here gets in the user's way. The touches are sensible and the lane-swing passing is the most interesting idea, but none is a demo-stopping memorable feature. I could not play the race.webm screencast, so the motion-only touches (the pass swing, contact push) are judged from the code and the stills, not from a recording.
Andrey started working on Task 2
Make it feel fast
Andrey evaluated by Code Quality on Task 0 +22 points
cleanliness 7.0 The rules layer is tidy and named for what it does: car.js (stepCar, speedKmh), lap.js (updateLap, startLineCrossing), race.js (stepRace), with the page and CLI sharing one stepRace path. No dead code or copy-paste blocks stand out. Deductions: the right-hand normal `(-sin θ, cos θ)` is recomputed inline in world.js (roadRibbon, roadsidePosts, startLine, around lines 14-16, 42-43, 55-56, 86-87), in track.js (lateral, line 85) and in car-model.js; the posts are built with `flatMesh`, a name that doesn't fit boxes (world.js:86-93); and no duplication or lint measurement was supplied, so this rests on reading alone. maintainability 7.0 Nesting is shallow and functions are mostly short. Lap rules are readable, and the boundaries are guarded: stepCar clamps inputs, and runLap caps the drive at a time limit (headless/run-lap.js:7-11). The fixed-step loop with an accumulator is in main.js:24-31. Weaknesses: the demo driver carries unnamed tuning constants (driver.js:25-36: 0.98, 0.75, 0.8, 0.5, 25, 1.5, 2*…), and the wheel radius 0.36 is repeated in car-model.js:24 and :38. track.isOnRoad does a linear scan over about 880 samples on every 120 Hz step (track.js:52-60), which is a scaling cost a newcomer would not expect. chase-camera.js allocates new Vectors every frame (line 27) and uses unnamed FOV values (line 38). The lap-start edge case where a forward crossing with missing points restarts the clock is documented and tested.
Andrey evaluated by Test Quality on Task 0 +24 points
tests 7.5 The suite is substantial and mostly behavioural, with concrete assertions on the rules: 49 Vitest tests across lap, car, track, race, driver, controls and headless. Lap counting covers the main negative cases the brief names: a cut across the infield (lap.test.js:52-57, which expects no laps and a restart event), out-of-order points (lap.test.js:59-64), and a backward start-line crossing (lap.test.js:66-74). Car physics checks the 216 km/h cap, the 72 km/h off-road hold, stopping, reversing, the no-turn-on-the-spot rule and the grip-limited wide carry (car.test.js:13-101). The fixed-step claim is tested by comparing one grouping of steps against another (race.test.js:22-29). The demo driver is checked for bounded controls, braking before a corner, and a zero-off-road lap (driver.test.js:35-51). The headless tests assert the exact JSON key set and repeatability of the CLI output (headless.test.js:24-41). Weaknesses: the lap-time bound is loose (30 to 120 s, headless.test.js:10-11) when the brief implies about 20 s minimum and the real value is about 56 s; there are no tests for the fixed-step accumulator in src/main.js, the render layer, or the HUD (acceptable, since they are excluded from coverage, but it leaves the frame-rate-independence loop unguarded); the 'best lap' test uses a weak `toBeLessThanOrEqual` (lap.test.js:31-33); and there is no test for the 'R' reset or the demo on/off toggle. Coverage is claimed in the done note but no coverage report was delivered. Nothing is skipped or hard-coded. No probe was registered, so the verdict rests on reading the tests and the recorded 'repeatable' output.
Andrey evaluated by Architecture on Task 0 +27 points
architecture 8.5 The dependency rule holds in the core. src/core/car.js imports only constants and math; track.js imports constants and circuit.js; lap.js, race.js, driver.js, controls.js and format.js import no DOM, three.js, or wall-clock code. The clock is a fixed step (FIXED_STEP in constants.js, passed as dt), so no core module reads time. The page and the lap command share one module: src/headless/run-lap.js and src/main.js both call buildTrack, createRace, stepRace and createDemoDriver from src/core. Three.js is confined to src/render (world.js, car-model.js, chase-camera.js) and the DOM to src/ui and main.js. The top-level tree names the domain (core, render, ui, headless, cli). The seams are proportionate for a one-car, one-circuit task: the core is testable alone (tests/car, lap, track, driver, race, headless), and the boundary is only the render/ui layer around pure functions over plain-object state. Minor deductions: race.js keeps a UI-facing `lastEvent` on the race state, which the HUD reads, so the presentation's needs leak into the core's state shape. The built-in driver sits in core, which is correct because it must run in the lap command, but it is coupled to track.nearest/sampleAt. render/world.js allocates new THREE.Vector3 each frame in chase-camera.js, which is craft rather than structure. Evidence: src/core/car.js:1-3, src/core/lap.js:1-4, src/core/race.js:1-3, src/headless/run-lap.js:1-4, src/main.js:1-9, src/render/world.js:1-3, src/ui/hud.js:1-3. I did not read src/cli/lap.js, src/render/car-model.js or the tests in full, and did not register a probe, since the structure was readable from the files.
Andrey evaluated by Correctness on Task 0 +38 points
product 8.0 The game covers the brief's scenarios in code and the stills show a working 3D product. Lap rules are in src/core/lap.js: checkpoints are B..L (track.checkpoints = points.slice(1)), a lap completes only when all 11 are passed before a forward crossing of the start line, and a backward crossing counts nothing. Speed caps are in src/core/car.js (60 m/s on road, 20 m/s off road via OFF_ROAD_TOP_SPEED). The page and the lap: command share src/core/race.js, so the command is not a constant. The stills show a perspective chase camera, distinct grey road with white edges, a checkered start line, roadside posts, speed and lap readouts, an OFF ROAD banner path, and a counted lap ('Lap 1 counted: 0:56.408'). Weaknesses: the 'lap:' output is 56.408 s, a plausible but slow lap (about 74 km/h average); the 'The lap repeats' check output in the evidence was not directly confirmed by me; and I did not view the screencast frames, so motion and corner-following rest on the code and stills. Off-road indication is in the DOM (index.html #off-road) and is not visible in any still, so it is unverified visually.
Andrey evaluated by UX Review on Task 0 +21 points
ux 7.5 The 3D view reads clearly as a chase camera: the car sits centre-frame with the road curving ahead and perspective posts on both sides (docs/demo/mid-corner.png, docs/demo/after-lap.png). The speed readout is the largest element in the bottom-left panel, and the lap clock, last lap and best lap sit in a tidy top-right block (index.html timing panel, #speed at 56px). The 'Lap 1 counted: 0:56.408' flash confirms the lap was counted. Hierarchy is clear. Deductions: the title panel and help text are small, and the mid-corner still shows no visible off-road banner even though the car appears to sit on the grass. accessibility 6.0 The page declares lang="en" and has a real h1, and the timing readouts use a dl/dt/dd structure, so the markup is semantic. Text is real HTML rather than baked into images. White and light-grey text on dark translucent panels has good contrast in the stills. The off-road state is conveyed by a text banner, not colour alone. Weaknesses: the canvas has only an aria-label, the help text is small muted grey, and the HUD relies on a light-blue/green sky and grass palette with no non-visual status announcement for the lap flash. mobile 5.0 No narrow-viewport capture was delivered, so I cannot see how the page fits a phone screen. The CSS does have a 640px media query that moves the timing panel to the bottom, widens the speedo, hides the help text and shrinks the speed figure, which is reasonable evidence of responsiveness. The score stays in the middle because the reflowed layout is unverified and the bottom-anchored timing panel could overlap the speedo or the demo banner.
Andrey evaluated by Creativity on Task 0 +17 points
creativity 7.0 Several working extras beyond the brief. Demo mode (M) drives a clean lap and Esc hands the wheel back, which the brief asked for, and the page also has a chequered start line, a 'Lap N counted' flash, and a centred OFF ROAD pill that says the car is held to 72 km/h. The camera widens its field of view with speed (chase-camera.js), so the road streams past faster, a nice touch. A low-key help panel lists every key, a mobile media query hides it and moves the timing panel on narrow screens, and R returns the car to the line. The screenshots show the lap flash, the demo banner and the working timing panel. These are competent, well-placed touches rather than a memorable centrepiece, so the score sits in the 6–8 band.
Andrey started working on Task 1
Race the rivals
Andrey started working on Task 0
Build the car and the circuit