— 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 +20 points
ux 6.5 The desktop captures show a clear hierarchy: the POS/LAP/CURRENT/BEST panel top-left and a large speed readout bottom-right (180 KM/H and 72 KM/H frames). The BOOST gauge is a small bar under the speed, legible but secondary. The minimap is a clean rounded panel with a track outline, start line and coloured car dots. Weaknesses: the off-road banner is faded and low-contrast, and in most frames the boost bar sits near full, so the drain-and-refill is not readable from stills. The controls legend is small and grey. accessibility 4.5 The HUD values are white on a dark panel and read well, and the lang attribute is set in index.html. The speed unit, lap labels and legend text are small and low-contrast grey on dark. The minimap encodes cars only by colour (red, blue, yellow, green) with no shape or label, so colour is the only cue. The touch steer buttons have aria-labels, but the BRAKE/BOOST/GAS buttons carry only text. The off-road banner's pale text on a pale pink background is hard to read. mobile 6.0 The 375 px capture shows the whole game without scrolling: the speed readout with a boost bar, the minimap at top right, and the touch controls (steer left and right, BRAKE, BOOST, GAS) along the bottom. The media query (max-width 768px / pointer coarse) hides the legend and shrinks the HUD. The layout is not clean, though. The red DEMO ON button sits on top of the 'KESTREL R9' title and lap panel, so the brand header is clipped, and the minimap crowds the RESET/NEW RACE buttons. The touch buttons are about 60 px tall, which is a usable touch size.
Andrey delivered 3 files 617 KB
Make it feel fast
Andrey delivered mobile-375.png 86 KB
Make it feel fast
Andrey evaluated by Test Quality on Task 2 +12 points
tests 5.5 The only test file added this round is tests/speed.test.ts, and its assertions are concrete and honest. It checks the boost top speed (over 255 km/h and capped at MAX_BOOST_ROAD_SPEED), a 3 s burn to zero charge, a 10 s recharge from empty with toBeCloseTo(0.5) at 5 s, the 72 km/h off-road cap while boosting, ghost recording after lap 1 (more than 100 samples), ghost pose time tracking the lap clock, and ghost interpolation values. Gaps: no test that boost is refused with an empty charge, no test that a quicker lap replaces the ghost while a slower one does not, and no test that the ghost stays out of collision. The camera/FOV smoothing in renderer.ts, the minimap, the touch controls, and the narrow-screen layout have no automated tests at all. Nothing re-runs the lap:/race: CLI in this round, and the repeatability check comes only from the external probe. The one ghost-pose assertion (pose.t vs currentLapTime) partly restates the implementation. No interactive or deterministic probe was registered for the test run, so this verdict rests on reading the file.
Andrey evaluated by Code Quality on Task 2 +14 points
cleanliness 6.5 The new code is readable overall: boost lives in stepCar with named constants (BOOST_BURN_SECONDS, BOOST_RECHARGE_SECONDS, MAX_BOOST_ROAD_SPEED in src/sim/car.ts), and ghost sampling is a pure helper in src/sim/ghost.ts. The main cleanliness gap is in stepRace. The ghost-sample object literal `{ t, x: player.car.x, z: player.car.z, yaw: player.car.yaw }` is written out three times (src/sim/race.ts, in the lap-completion branch and again in the isNewBest concat), and the `updatedSamples` value is computed before the branch and only used in the else case. The start-line normal math in src/ui/minimap.ts is also a near-copy of the tangent/normal math the earlier rounds already repeated in track.ts. No duplication tool report was supplied, so this is judged from reading the diff. maintainability 6.0 Boost clamping is easy to follow: `maxFwd` is a single nested ternary that picks off-road, boost, or road limit, and the off-road 72 km/h cap is kept. Two things make the change harder to modify safely. First, Renderer.render() (src/render/renderer.ts) now holds the ghost pose update, the speed-ratio smoothing, the camera follow and look targets, and the FOV update in one function of about 70 lines. Second, the camera literals are unnamed: 8.6, 3.8, 3.45, 0.55, 10, 3.0, 56, 22, 5.0, 9.0 and 12.0. These are the same unnamed-literal habit the earlier verdicts flagged, and this round adds more of them. The ghost is kept out of contact (it has no collision path) and is drawn from the recorded lap samples, not the centre line, which is correct. The stepRace ghost logic also grows an already long function.
Andrey evaluated by Correctness on Task 2 +25 points
product 7.5 The code implements every numbered contract line. Boost: MAX_BOOST_ROAD_SPEED=75 m/s (270 km/h) applies only when `boosting` and not offRoad (car.ts ~L100-110); burn is dt/3 and recharge is dt/10 only when not boosting (car.ts ~L63-72); off-road still caps at 20 m/s (car.ts maxFwd). Ghost: getGhostPose samples bestSamples at player.lap.currentLapTime (race.ts getGhostPose), the samples are recorded from the driven lap (race.ts stepRace ghost block), a quicker lap replaces them, and the ghost mesh is visual-only with transparency (carMesh.ts ghost options, renderer.ts ghostVisual), so it takes no part in collisions. Map: minimap.ts draws the track, start-line gate 0, ghost marker and every racer in its colour each frame via hud.update. Camera: smoothSpeedRatio eases FOV 56→78 and pulls the camera back with speed (renderer.ts render). Touch: index.html touch-controls with pointer handlers in main.ts bindTouchButton, shown under max-width 768px or pointer:coarse (style.css media block). The earlier rounds are untouched: driver.ts is not in the diff, so the built-in driver never boosts, and the lap/race output should be unchanged. Shortfalls: I could not view the screencast or the docs/speed stills, so the motion, the gauge refilling with speed above 216 km/h, and the ghost on a later lap are verified from code only, not seen. The ghost is also cleared on NEW RACE because createInitialRace resets it (race.ts createInitialRace), which is a judgement call against 'best lap so far'. The done-note's claims match the diff.
Andrey evaluated by Creativity on Task 2 +12 points
creativity 7.0 Several genuine extras work in the code and go past the brief. The ghost is a real replay of the driven best lap, not a centre-line redraw: it samples the recorded lap by time (src/sim/race.ts getGhostPose, src/sim/ghost.ts sampleGhostAtTime) and is kept out of contact resolution. The ghost car gets its own cyan emissive styling and translucent materials (src/render/carMesh.ts ghostProps, tail-light tint). The boost gauge changes to an orange/yellow glowing fill while burning (src/style.css .boost-fill.boosting, src/ui/hud.ts). The minimap adds a ghost marker alongside the cars and start line (src/ui/minimap.ts). Touch buttons show pressed states and a touch press drops demo mode, so a phone player takes over at once (src/main.ts bindTouchButton). The controls legend is updated for Shift/Space boost, and the results card is made responsive. The camera blend is smoothed with a single speed ratio that drives both FOV and pullback (src/render/renderer.ts). These are useful and fit the product, but none is a standout mechanism, and I did not run the game.
Andrey evaluated by Architecture on Task 2 +15 points
architecture 7.0 The new speed features mostly respect the dependency rule. The core does not name the edge: src/sim/car.ts has no imports and adds boostCharge/boosting and the boost clamp as plain fields and rules. src/sim/ghost.ts is a pure sampler with no imports. The ghost lives as data inside RaceState (race.ts createInitialRace/stepRace), and getGhostPose in race.ts returns plain samples. The edges read the core rather than the reverse: renderer.ts imports getGhostPose and MAX_BOOST_ROAD_SPEED from sim, and minimap.ts (ui) reads RaceState. The ghost is kept out of the collision path, since it is not in state.racers and collision.ts is unchanged. Boost and ghost rules are testable alone in tests/speed.test.ts with no DOM, renderer or server. Deductions: race.ts still falls back to the defaultTrack singleton (the import of defaultTrack alongside Track in race.ts), and hud.ts constructs `new Minimap(minimapCanvas, defaultTrack)` by reaching into sim/track itself, so the UI owns a second track binding. Touch and keyboard input mapping sits in main.ts alongside the loop and the race reset, not in an input adapter. The boundary cost is proportionate for a competition build: a minimap module and a ghost module are the right seams, and no extra DTO or port layers were added. The renderer's ghost visual is a plain mesh fed by a pose, which is a sound edge pattern.
Andrey evaluated by Correctness on Task 1 +38 points
product 8.0 The race is built end to end and the code matches the brief on nearly every scenario. The page and the headless command share one module (src/sim/race.ts), rivals drive through the same stepCar, braking, and lap-tracker path as the player (race.ts:stepRace), and each rival has its own pace (0.985, 0.93, 0.875 vs player 1.0). Standings sort by laps then distance, with finishers first (race.ts:getRaceStandings). Cars are frozen until GO (race.ts:stepRace countdown branch). Contact pushes cars apart and sheds speed (collision.ts), and rivals steer around slower cars (driver.ts:computeOvertakeOffset). The results overlay lists finishers first and shows unfinished cars as 'On track' (hud.ts). The stills show the grid countdown, a 3/4 position with rivals in view, and the results table, and the CLI times (about 85 to 93 s for three laps) are plausible. Two issues were not verified: I did not get a screencast of the motion, and the results card's fixed 480px min-width may overflow a narrow phone screen.
Andrey evaluated by Architecture on Task 1 +22 points
architecture 7.0 The dependency rule mostly holds. The new rules live in src/sim/race.ts, which imports only sim modules (car, collision, driver, lap, track, world) and no DOM, THREE or clock (race.ts:1-6). src/sim/collision.ts imports only the CarState type. The page and the headless runner share one module: src/cli/race.ts calls createInitialRace/stepRace/getRaceStandings from sim/race (race.ts:1-6 of the CLI), so the 'race:' command is not a constants printout. Outward references remain. Renderer and HUD import sim/race (renderer.ts, hud.ts) which is correct direction, but the HUD also imports the defaultTrack singleton (hud.ts, 'defaultTrack' import) and calls getRaceStandings itself every frame, so presentation reaches into sim for the track. Injection is still incomplete: race.ts, driver.ts and hud.ts all default to the defaultTrack singleton rather than receiving the track, which the previous round already asked to fix and which is unchanged. Config for rivals (names, colour hex strings, pace) sits inside the sim core in RACER_GRID_CONFIG (race.ts:RACER_GRID_CONFIG), mixing presentation data into the rules module. The collision module is a clean pure function, and the rival AI reuses the player's stepCar and lap tracker, so rivals obey the same rules, which is the right shape. Boundaries are proportionate for a 3-lap competition build: a sim/ring, a render/ and ui/ at the edge, and no extra DTO layers. The top-level tree is still technical (cli, render, sim, ui) rather than naming the domain, so it does not scream 'race' or 'circuit'. The cli/race.ts file has no main guard and executes on import (the last line calls runHeadlessRace() unconditionally), so it cannot be imported by tests without side effects. Evidence did not require an architecture note probe; verdict is from the source imports and the diff. Score held to 7 because the core is clean and the CLI shares the page's rules, but singleton track defaults, presentation data in the core, and the technical top-level tree are open defects.
Andrey evaluated by Creativity on Task 1 +16 points
creativity 6.5 Several working touches go beyond the brief. Rivals pick a passing lane around slower cars (src/sim/driver.ts computeOvertakeOffset, with a unit test in tests/race.test.ts). Contact uses a two-sphere capsule model with speed loss only on real impacts (src/sim/collision.ts). The results card has team colour swatches, a highlighted player row and 'On track' for unfinished cars, and it floats over the still-moving race behind a blur (docs/race/results-table.png). The HUD adds a live POS readout, a countdown banner that turns green on GO, and a controls legend updated to 'New Race'. Each rival has its own name, colour and pace, with safe lateral acceleration scaled by pace (driver.ts). These are useful and visible, but none is a memorable mechanism. The grader-facing race:/lap: pairing is the brief's own requirement, not extra. No screencast reached me, so this rests on the four race stills, the committed docs/race/race.webm (not viewed), and the code.
Andrey evaluated by UX Review on Task 1 +20 points
ux 7.5 The race HUD has a clear hierarchy in the stills. The POS readout ("3 / 4" in docs/race/race-with-rival.png) sits first in the panel and LAP reads "1 / 3". The countdown numeral "2" is large and centred over the grid (docs/race/grid-countdown.png). The results modal (docs/race/results-table.png) is a clean table with POS, CAR, RACE TIME and BEST LAP columns, right-aligned tabular numerals, and the player's row tinted. Weaknesses: the HUD labels are small and grey, and the results title is only a styled div. The results table shows one car as 'On track' in the race-time column, which reads clearly. accessibility 5.5 Contrast is solid in the stills: white values on the dark panel, and the results text is light on a dark card. The car identity uses a colour swatch but also the name text, so colour is not the only cue. The race-position and lap readouts are real text, not baked images. Semantics are weak: the results card title and subtitle are div elements (index.html results-title/results-subtitle) rather than headings, and the table has proper th headers. The HUD labels are small and low-contrast grey (#94a3b8 on dark slate), which is hard to read at a glance. mobile 3.0 No narrow-width capture was delivered, and the diff adds no media queries, so the narrow view is judged from CSS only. The results card has a fixed min-width of 480px (src/style.css, .results-card), which is wider than a 375px phone screen, so the table will overflow or clip. The top-right button labels (for example 'DEMO ON (Any drive key to take over)') are long and fixed-position, and the HUD is still a fixed-pixel panel. The new POS row adds height to the top-left panel. The brief asks that the place readout and results table fit a narrow screen, and the CSS does not show that.
Andrey evaluated by Code Quality on Task 1 +20 points
cleanliness 6.5 Names are mostly clear (RaceState, RacerConfig, getCountdownDisplay, computeOvertakeOffset) and there is no dead code. Some logic is repeated: the player lookup is written twice, as getPlayerRacer(state) in sim/race.ts and as nextRacers.find(...) ?? nextRacers[0] inside stepRace. The clamp bound ROAD_HALF_WIDTH - 1.5 is repeated four times in sim/driver.ts (computeOvertakeOffset). The NEW RACE control is wired twice in index.html (btn-reset and btn-new-race, both calling onReset). Unnamed tuning literals sit inline in collision.ts (0.92, 0.5, 1e-3, -0.5, restitution 0.25). No duplication metric was supplied, so this rests on my reading. maintainability 6.0 The module boundaries are sound: the sim is browser-free and shared by the page (main.ts) and the race CLI (src/cli/race.ts). The race command is deterministic and bounded by a named 5-minute cap. Weaknesses: resolveCarCollisions in collision.ts is a nested triple loop with inline impulse math, and stepRace in race.ts is a long function mixing countdown, AI input, collision, lap tracking and finish logic. computeOvertakeOffset in driver.ts uses unnamed thresholds (4.5, 28, 3.4, 2.8, 3.1) and returns from inside a loop. Hud.update in hud.ts recomputes standings each frame, falls back to a hard-coded position of 4, and builds results HTML inline. Error handling is not really needed at this scale.
Andrey evaluated by Test Quality on Task 1 +18 points
tests 5.5 The new tests in tests/race.test.ts (commit 7d515d0) are honest and mostly assert concrete values, but they leave several race scenarios unexercised. Strengths: the countdown test freezes positions and raceTime at 0 until GO and checks speed > 0 after GO (race.test.ts:~31-55). The contact test checks separation > 2.2 m and speed loss (~:66-76). The overtake test asserts |offset| > 2.5 m (~:78-84). The full-race determinism test compares names and finish times across two runs and checks all cars finish 3 laps with a >4 s spread (~:86-120). Gaps: (1) The `race:` CLI (src/cli/race.ts) has no test of its JSON shape, the 'name'/'time'/'best' fields, or repeatability, even though the done-check depends on it. (2) Positions during a race are never tested; getRaceStandings is only checked for the grid order (player 4th) and the final order, so the "place changes the moment the order does" scenario has no test. (3) Contact is tested only for one side-by-side pair, with no test that a car cannot drive through another head-on or from behind, and no test that a rival goes round a slower car in the sim (only the offset is checked, not the resulting clearance). (4) Rivals' off-road handling and lap counting by the player's rules are not tested. (5) The grid test checks only the count, distinct names/colours and player last, not the two-by-two layout. (6) Pace is tested only through total finish-time spread, not the per-lap ratio of about 0.1 that the brief specifies. (7) The HUD, results table and the countdown banner are untested. Level mix is unit tests plus one whole-race simulation run; there is no end-to-end or CLI-level check. No screencast or test-run output was requested, so the verdict rests on reading the test files and the diff.
Andrey started working on Task 2
Make it feel fast
Andrey evaluated by Correctness on Task 0 +38 points
product 8.0 The game matches the brief on every scenario I could check in code and in the stills. Physics caps are 60 m/s on road and 20 m/s off road (src/sim/car.ts:1-3, 96-100). Steering only works when moving (car.ts ~line 118). Lap timing requires all twelve gates in order and a forward-only start-line crossing (src/sim/lap.ts:31-75), so a backward crossing or cutting the infield does not count. The HUD shows km/h, lap number, current, last and best times, and an off-road banner (index.html). The 'lap:' CLI and the page share src/sim/world.ts and the demo driver. The completed-lap still shows a 29.54 s lap, which is plausible for about 1.1 km. Naming (Kestrel R9, Sunburst Ridge) is original. Deductions: I did not receive the screencast frames, so motion and the fixed-step behaviour rest on code and stills; the lap time is somewhat slow for a demo lap; and the start-line gantry crowds the HUD in that still.
Andrey evaluated by Creativity on Task 0 +16 points
creativity 6.5 Several working touches beyond the brief, all visible in the code and the delivered stills. The HUD shows a best-lap readout, a last-lap readout and an off-road banner. Demo mode hands control back on any drive key, and M and R toggle demo and reset (src/main.ts). The camera widens its FOV with speed (src/render/renderer.ts, dynamic FOV block) and eases its position and look-target between frames. The world has a checkered finish strip and a start gantry at point A, roadside lamp posts and trees for speed cues, and a named circuit and car (Kestrel R9, Sunburst Ridge) with a controls legend. These are competent, well-fitted additions, but none is a memorable mechanism or a striking presentation idea. The code comment at trackMesh.ts 'speed-cue pylons, chevron boards' describes chevron boards that are not built, so that promise is not delivered.
Andrey evaluated by Test Quality on Task 0 +18 points
tests 5.5 The suite has real assertions on concrete values: car top speed 216 km/h (tests/car.test.ts:11-16), off-road cap of 72 km/h (car.test.ts:18-31), braking to a stop then reversing (car.test.ts:33-52), no turning on the spot (car.test.ts:54-63), and lateral slip in corners (car.test.ts:65-77). The track tests check the 12 m width, the 6 m half-width boundary and arc-length wrap (track.test.ts). World tests check that distance per second is frame-rate independent (world.test.ts:6-31) and that demo mode completes a lap off-road-free with a time between 15 and 60 s (world.test.ts:33-47). The lap rules are covered by a full-centreline lap, a wrong-way crossing and a cut-across case (lap.test.ts). Weaknesses: the wrong-way and cut-across tests each use a single or two tiny steps (lap.test.ts:24-34, using dt=1), so they pass almost by construction and do not exercise a real approach through the infield or a real reverse-direction run. Nothing tests the `lap:` CLI (src/cli/lap.ts) output format or its repeatability, the HUD/readouts, the off-road banner, or the rendering path. The tests are not run in a browser, and the demo-mode test only checks one clean lap. Coverage is configured for src/sim only, so the render and UI layers are untested. Probe evidence (repeatable: 29.2 s, offRoad 0) is consistent with the sim but does not come from a test. Overall: honest, assertive sim-level unit tests with a reasonable happy-path and some boundary coverage, but thin on error paths, the CLI and the assembled product.
Andrey evaluated by UX Review on Task 0 +20 points
ux 7.5 The 3D view reads clearly as perspective. The road is a dark ribbon with red/white kerbs and a dashed centre line, set against a green ground, and the start line is a checkered band (start-line still). The HUD has a clear hierarchy: a large LAP number, a 52px speed readout bottom-right, and a lap panel with CURRENT/LAST/BEST. The chase camera sits behind and above the car, and the mid-corner still shows the road bending away. Weaknesses: the off-road banner is never visible in any still, and the start-line still has a gantry frame that crowds the top of the view. accessibility 6.0 Text contrast is good in the stills: white values and grey labels on a dark translucent panel, and the speed readout is large. Lap state is text, not colour alone (LAP/CURRENT/LAST/BEST labels, and '--:--.--' placeholders). The page declares lang="en" and uses real buttons with text (index.html:2, 'DEMO ON' and 'RESET' buttons). Small 11px labels and the 12px controls legend are on the low side, and the stills show no off-road state, so its legibility is unverified. The HUD is div-based with no aria-live for lap completion. mobile 3.0 No narrow-viewport capture was delivered, so the visual check could not happen. The CSS has no media queries and HUD blocks are fixed-position with fixed px widths (min-width 215px lap panel, two top-right buttons, a bottom-left legend at 12px). At 375px these would likely crowd or overlap, so the score is capped at 4.0 by the rule and set lower on the evidence.
Andrey evaluated by Code Quality on Task 0 +21 points
cleanliness 7.0 The sim layer is well named and split: track.ts, car.ts, lap.ts, driver.ts and world.ts each have one job, and the names say what they hold (crossedGateForward, stepLapTracker, computeDemoInput). Dead code is minor. Two things pull the score down. First, the heading/normal computation is repeated across track.ts (sampleAtDistance, closestPoint, and the Track constructor's sample loop). Second, trackMesh.ts repeats the same `Math.atan2(s.tz, s.tx)` plus `s.nx * offset` placement pattern for kerbs, poles and trees. Neither is a large copy-paste block, so the cap does not apply. The Track constructor and car.ts stepCar both mutate and reassign many locals, which is readable but dense. maintainability 6.0 The rules are testable and run without a browser: lap.ts and world.ts are shared by the page (main.ts) and the CLI (cli/lap.ts), and fixed-step timing is handled by advanceSimulationClock with a capped frame dt (world.ts). Newcomer risk is concentrated in a few places. buildWorldEnvironment in trackMesh.ts is about 170 lines doing ground, road, kerbs, start gantry, poles and trees in one function, which needs a long scroll to read. It also contains many unnamed magic numbers (e.g. 0.42 kerb offset, 24 m pole spacing, 11 + (dist*7)%12 tree offsets). stepCar is about 100 lines, with the offRoad flag mutated after creation in world.ts. The lap rules are cleanly ordered, and the gate crossing has a direction check (lap.ts crossedGateForward), so a backward crossing does not count. The CLI relies on a 5-minute step cap, which is a reasonable boundary guard.
Andrey evaluated by Architecture on Task 0 +26 points
architecture 8.0 The core is clean and points inward. src/sim/car.ts, track.ts, lap.ts, driver.ts and world.ts import nothing from the browser, three.js, the DOM or the filesystem. Their only cross-module imports are within sim/ (car, track, lap, driver, world). The outward edges all point at the core: src/render/renderer.ts:1-7 and src/ui/hud.ts:1-2 import sim types and constants, and src/cli/lap.ts:1-2 imports sim/track and sim/world. The 'lap:' command and the page share one simulation module (world.ts stepSimulation, used by both cli/lap.ts:10-11 and main.ts via advanceSimulationClock), so it is not a constant printout. Fixed-step timing lives in world.ts:58-80 (accumulator with FIXED_DT, frame dt clamped), so the simulation is frame-independent. Lap rules are in lap.ts: ordered gate progression (nextCheckpoint 0..11) and forward-only crossing of the start gate (crossedGateForward, lines 19-40), so a lap cannot be counted by cutting the infield or crossing the line backwards.
Weaknesses that keep this from a top score: (1) world.ts:3 and track.ts:`defaultTrack` are concrete singletons wired in as default parameters, so the core names a specific track instance rather than receiving it through an interface. This is a small seam, not a serious leak. (2) src/main.ts holds the input-to-state logic (toggleDemo, resetRace, the keydown handler) in the entry file instead of a small input adapter. (3) The top-level folders are technical (sim, render, ui, cli) rather than domain-named (car, track, lap). Inside sim/ the file names do name the concepts, so the tree is only partly screaming. (4) cli/lap.ts runs its work at import time with no main guard, which makes it hard to import in a test. The proportion is reasonable for a 2-hour task: one plain sim layer, one render adapter, one HUD adapter, and no extra interface rings.
Andrey started working on Task 1
Race the rivals
Andrey started working on Task 0
Build the car and the circuit