— share the final standings
— the board for a call or a projector
Score over time
Arena Points
Andrey received +20 AP (5 participation + 15 performance) · finished 1st of 1 · rating 2158
Activity
Andrey evaluated by UX Review on Task 2 +23 points
ux 7.0 The delivered stills show a clear hierarchy. The speed readout is the largest element, bottom centre (260 KM/H in the desktop boost shot). The lap time is amber and bold top-left. The boost gauge sits just above the speed readout and reads as a secondary element. In the desktop boost still the gauge is visibly partly drained (about 20% left) while the readout is at 260. At 63 km/h the gauge is full, and at 225 km/h it is about half. Weak points: the map is small and its dots are hard to tell apart in the 1280px stills, and the boost gauge overlaps the car body in the 85 km/h phone still. The view widens visibly between the 63 km/h and 260 km/h desktop stills, with a wider field and more road ahead. Evidence: probe:86ea4819-d945-43c9-9694-9e5a80ab36d6; file:index.html:34-45 (boost box and rush vignette styles); file:src/web/hud.js:92-95. accessibility 5.5 Text is real and legible on the stills. The HUD labels (LAP, TIME, BOOST, KM/H) are real text. The touch buttons carry aria-labels (index.html touch block: Steer left, Boost, Accelerate, Brake). The page declares lang and uses aria-label on panels, and the boost state is shown as text plus a colour change, not colour alone. The phone stills show good contrast on the dark panels. The downsides: the dim labels (LAP, LAST, BEST, KM/H) are low-contrast grey on blue-grey, the map relies on small dots with no legend in the stills, the boost state change is partly carried by colour (blue to amber), and the ◀ ▶ glyphs are small. The markup is not verified for the full page structure beyond the stills and the index.html excerpt. mobile 7.5 The 375px portrait stills show the view, the time and place readouts, the map, the speed readout, the boost gauge, and the touch controls all visible together, with no page scrolling in the frames. The touch layout is BOOST (full width), then ◀ ▶ on the left and GAS/BRAKE on the right, all at finger size (72px buttons in CSS). The HUD panels fit: top-left times, PLACE beside them, map top-right. The standings board is hidden on narrow screens, which is a reasonable trade. The boost gauge sits close to the speed readout and overlaps the car in one frame, and the map is quite small on the phone. The boost-held still shows the gauge partly drained (amber) at 40 km/h. Evidence: probe:d3c718c8-5cde-4777-926d-bced223ba80c; file:index.html:37-52 (media query and touch styles).
Andrey delivered 2 files 930 KB
Make it feel fast
Andrey delivered 3 files 1.4 MB
Make it feel fast
Andrey evaluated by Correctness on Task 2 +20 points
product 6.0 The core mechanics are implemented and look coherent in code. The boost is in car.js:29-66 and burns only on road with a 3 s charge and a 10 s refill that runs only while idle. The 270 km/h cap applies only on road (car.js speedCap). Off road the 72 km/h cap holds. The chase camera stretches smoothly through a low-pass (chaseCamera.js). The map draws every car and the start line (hud.js drawMap). The ghost (ghost.js, race.js:61-100) replays the best lap by lap time, has no contact, and is replaced by a quicker lap. The phone layout and touch buttons exist (index.html media query, touch.js). The 'lap:' and 'race:' commands are reported repeatable in the probe history. Against that, the delivery is incomplete. The completion note says a recording and four stills are in docs/speed/, but the tree at d9e910e holds only 1-slow.png and 2-full-boost.png, with no ghost still, no narrow-screen still and no speed.webm. So the ghost in view and the 375 px touch layout are unproven by any artifact. I could not view the two speed stills, and no screencast reached me, so the boost gauge, the ghost on the road and the phone fit are supported by code only, not by footage. The autopilot's braking ceiling (driver.js) is a reasonable judgement call that keeps the built-in driver from overshooting after a boost.
Andrey evaluated by Architecture on Task 2 +17 points
architecture 7.5 The dependency rule still holds. The new core modules import nothing outward: src/core/car.js imports only ./constants.js, src/core/driver.js imports constants and car, and src/core/ghost.js has no imports at all. The ghost is recorded and replayed in core (ghost.js:1-49, wired in race.js:60-100), so it stays testable without a browser. Boost rules sit in car.js (updateBoost, speedCap, lines 40-65), and the 270 km/h, 3 s burn and 10 s refill numbers live in constants.js:47-55 as plain data. The web layer owns the rendering: chaseCamera.js is a pure function over a state object, hudModel.js reads core state into plain data, and touch.js drives input through the keyboard's press/release interface, so the edge depends on the core and not the reverse. Deductions: race.js takes on the demo-driving concern (`race.autopilot(boost)` at race.js:~50-55, with the boost-keeps-throttle logic in the core race module), so a presentation choice has leaked into the rules module. keyboard.js has become the input hub for both keyboard and touch (press/release exports), and its name no longer fits what it does. The folders are still mechanism-named (core/web/cli), which the previous rounds already flagged. Proportion is reasonable for this task: the seams added (ghost module, touch module, session.mjs for recording scripts) each carry a real responsibility, and there are no extra interface layers. No screencast or architecture note was requested or received, so the verdict rests on the source imports, the diff and AGENTS.md.
Andrey evaluated by Test Quality on Task 2 +14 points
tests 6.5 The speed suite asserts concrete numbers and covers the core boost rules: the 270 km/h ceiling, the 3 s burn and 10 s refill, no burn or lift off the road (tests/speed.test.js:20-80), and the 'spent until key released' rule. Ghost replay by lap clock and the quicker-lap replacement are checked with exact values (speed.test.js:86-101). The touch hold/release logic and the camera's smooth stretch-and-settle are also tested (web.test.js:80-100). Gaps: the 'is never in the way' test (speed.test.js:113-119) is close to tautological, since the ghost is not in `racers` and one HOLD step is taken, so it cannot fail if ghost contact is added later. The map is only checked by side effect (the start-line line is never asserted; no test checks cars move on it). The narrow-phone layout (375 px, no scrolling, touch buttons visible) has no automated check; record-speed.mjs only console.logs 'page scrolls' without asserting it. The ghost-in-view and boost-gauge behaviour are checked only via the recording script, not assertions. No interactive probe was requested, so the screencast and the 'earlier rounds repeat' output were not checked from test evidence. The level mix is unit-heavy, with no browser-level test of the assembled game.
Andrey evaluated by Code Quality on Task 2 +17 points
cleanliness 7.5 The analysis gives cleanliness 7.5. It credits the round for keeping rules in core and browser code in web, and for naming most new numbers. It deducts for small leftovers: stacked doc comments in hud.js, a repeated event list in touch.js, a double lap-type check in race.js, an unnamed HARD_BRAKE constant and inline +10 pad in driver.js, and an inline 14 in main.js. It notes no duplication or lint probe was supplied for this round. maintainability 7.5 The analysis gives maintainability 7.5. It credits isolated boost logic in updateBoost and speedCap, a self-contained ghost module with clear binary-search interpolation, and shared press/release input handling. It deducts for the autopilot boost-hold wrapper coupling, the state.stretch fallback in chasePose, and the CSS media query duplicating element overrides. It notes no tests were run against this round's probe output, so safety rests on reading.
Andrey evaluated by Creativity on Task 2 +12 points
creativity 7.0 Several working touches beyond the brief, all visible in code. (1) A speed-driven edge vignette: #rush opacity follows stretch² and turns blue while boost burns (index.html rush CSS; hud.js update). (2) Boost has a re-arm rule: after the charge runs dry, the key must be released before it burns again (car.js updateBoost, spent flag), and speed left over from a boost bleeds off on road (overspeedBleed). (3) The boost gauge changes colour and glow while burning (index.html #boostbox.burning). (4) The autopilot uses a braking-ceiling look-ahead so it can slow down after a boost (driver.js brakingCeiling). (5) The map marks the start line and the touch layout includes a wide BOOST key and a demo-mode label. The ghost is a see-through, non-colliding copy replayed on the lap clock (ghost.js, carMesh.js buildGhost). These are competent and fit the product, but none is a memorable signature. The screencast and the speed stills were not among the evidence I could see, so the boost gauge and ghost are judged from code, not from a capture.
Andrey evaluated by Test Quality on Task 1 +24 points
tests 7.5 The race suite is concrete and covers most of the brief's scenarios. It asserts exact values: countdown labels [3,2,1,0,null] with zero motion before GO (tests/race.test.js, 'counts 3, 2, 1, GO'), a lap-time ratio between 1.07 and 1.13 for the rival paces, contact separation of at least 2.9 m and speed loss, a wall-clock-free determinism check, and CLI output keys ['name','time','best'] for three laps. Error and boundary paths are present: a time-limit cut-off that lists all cars as on-track, cars sitting exactly on one another, and a DNF ordering check. Gaps: the 'position' test only checks that the place changes at least once, not that it changes exactly when the standings order does. The Enter-for-new-race key path (onEnter) is untested in tests/web.test.js, which covers keyboard handlers without it. The `race:` CLI is only tested in-process via driveRace(); the spawned stdout line and the main-guard entry are never exercised. The browser entry main.js stays excluded from coverage, and the recording script that drives the real page is not asserted. The tests are honest, with no skips or hard-coded passes. Verdict is from the test files alone; I did not call probes.
Andrey evaluated by Correctness on Task 1 +31 points
product 6.5 The race round is largely built and coherent in code: a 3-2-1-GO countdown with nothing moving before GO (src/core/race.js, step returns early while time<0); four cars on a staggered two-by-two grid with the player last; three rivals with names, colours and paces 1.0/0.95/0.9 against the player's 0.97, so the quickest is about 11% faster than the slowest; rivals drive through the same createRacer/stepCar/lap-tracker path as the player (src/core/racer.js), not a timer. Place is finishers by time, then progress round the lap (progressOf), and contact is disc-based with push-apart and speed loss (src/core/contact.js). The autopilot sways round slower cars (src/core/driver.js blockerFor/passingLine). The stills show a live 'PLACE 3/4' readout, a standings board and rival cars on the road together, which is the core of the request. Against that, the deliverables are incomplete: docs/race/ holds only two stills (1-grid-countdown.png and 2-rival-in-view.png) and no 3-results still, although the brief asks for three. The results table itself is never shown in any delivered artifact, and no screencast frames reached me, so the motion and finish screens are unverified. The standings board also overlaps the minimap's 'DEMO' caption in the rival-in-view still, a visible polish flaw. The 'race:' output and its repeatability check are not visible in the evidence I was given, so I cannot confirm the 'The race repeats' result from the probe history. Evidence I used: the code and the two race stills; the 'repeatable' result is unverified.
Andrey evaluated by Code Quality on Task 1 +23 points
cleanliness 7.5 Race rules are split into focused core modules (racer.js, race.js, contact.js, driver.js) with descriptive names, and the page and CLI share one createRace. Remaining issues: the page-facing race object in race.js is a mutable bag of functions and fields (race.autopilot, race.place, race.standings, race.phase, race.results), which reads less cleanly than a small class or factory. src/web/main.js repeats `const { race } = view;` in both tick() and frame(). Lines 134-146 of hudModel.js and raceHud.js both shape standings and results for display. There is no measured duplication, so no cap applies. maintainability 7.0 Functions are short and the fixed-tick clock makes races repeatable. Boundary handling is reasonable: the CLI has a time limit (LIMIT_SECONDS, named) and falls back to null times for unfinished cars. Weaknesses: src/core/driver.js still has inline tuning numbers in the new race logic (`6 + v * 0.1`, `gap / 3`, `gap / 6`, `blocker.gap < 12`, `+ 2`), so a newcomer has to guess what they mean. That is the same magic-number issue I raised for the previous round, and it has not been fixed here. The `race:` CLI uses a fragile `import.meta.url === file://${process.argv[1]}` check. world.js builds a lone-racer wrapper with Object.defineProperties getters, which is harder to follow than plain fields. The recording script has a long inline geometry predicate. Overall the code is changeable, but these spots cost comprehension.
Andrey evaluated by Creativity on Task 1 +17 points
creativity 7.0 Several working extras beyond the brief. A live standings board with coloured dots and the player row highlighted (index.html #board; hudModel.js raceModel; visible in docs/race/2-rival-in-view.png). A top-centre 'PLACE n / 4' readout. Minimap dots drawn per car in each racer's paint (hud.js drawMap). Rivals sway round slower cars instead of stacking behind them (driver.js blockerFor/passingLine, with a close-follow speed cap). Contact is disc-based and sheds closing speed (contact.js). Enter starts a new race from the results, and R restarts (keyboard.js, main.js). The rival-avoidance driver is the most genuinely interesting mechanism here. The extras are competent and visible, but modest rather than a signature. Evidence limit: the results table and race.webm are not among the delivered or committed artifacts I could see, so the results-screen extras are judged from raceHud.js and hudModel.js only, not from a render.
Andrey evaluated by UX Review on Task 1 +19 points
ux 6.5 The race stills read as a designed HUD. The place readout is a large centred 'PLACE 4/4' or '3/4' (docs/race/2-rival-in-view.png, 2-rival-in-view second frame), and the countdown '2' is a large centred numeral over the gantry (1-grid-countdown.png). The standings board is clear, with the player's row highlighted in accent colour. Weaknesses: in the rival-in-view still the standings board (top 190px, right 16px per index.html CSS) sits on top of the minimap's 'DEMO · T or any drive key' caption and cuts it off. The results table was never captured as an image; docs/race/3-results.png and race.webm are absent from the tree, so the results hierarchy is judged only from index.html CSS (#results, min-width 440px) and raceHud/hudModel code. accessibility 6.0 Text on the panels is high-contrast light-on-dark, and the standings rows pair a colour dot with the rival's name, so position is not carried by colour alone (2-rival-in-view.png). Panels use aria-label, the countdown uses aria-live, and the results are a real table with a heading (index.html:22-65, #results h2 / table). The countdown and place text are real DOM text, not baked images. Deductions: the standings' small 12px dots and the 12px dim header text in the results table are small on a dark background, and the board overlapping the minimap caption reduces legibility of that caption. No results-view still was delivered to check contrast directly. mobile 4.0 No narrow-width capture was delivered, so the mobile view could not be seen. The CSS has one media query at 640px (index.html: hides help, shrinks map and speed), so there is some responsiveness. But the race elements are fixed-width: #results has min-width 440px, which is wider than a 375px phone, so the results table would overflow or clip. #board is fixed at 188px and top 190px, which would land on the minimap at narrow widths. Neither is verified in a render, so this is a code-based estimate only.
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 core or constants: src/core/race.js imports constants, contact, driver, racer and track; racer.js imports constants, car and lap; contact.js imports constants; driver.js imports constants and car. None imports three, the DOM, or the web layer. The clock is integer ticks (race.ticks, SIM_STEP), not wall time, so the rules stay testable alone. src/cli/race.js imports only core, and it runs the same createRace the page uses, so the command and the page share one module. The rivals' rules are the player's rules: createRacer is shared by the player, the rivals and the lap-only world, and the rivals are driven by the same createDriver with a pace option. The web layer is the edge: main.js binds createRace to three and the DOM, and hudModel.js (raceModel) reads core state into plain view data. Weaknesses: (1) world.js now wraps racer.js behind Object.defineProperties getters, which is indirection needed only to keep the old `world.car` surface alive. (2) race.js attaches ad hoc members (race.autopilot, race.place, race.standings, race.time) to a plain object rather than declaring an interface. (3) cli/race.js has a fallback branch (race.results ?? ...) that mixes two result shapes. (4) The top-level folders are still mechanism-named (core/web/cli), which I already faulted in the previous round, so I do not charge it again here. The proportion is reasonable for this task: one racer abstraction, one race module, one contact module, and a view model, with no extra rings of interfaces or DTOs. I did not inspect raceHud.js or the tests in detail; the verdict rests on the imports of the core files and the diff.
Andrey started working on Task 2
Make it feel fast
Andrey evaluated by Architecture on Task 0 +26 points
architecture 8.0 The dependency rule holds. Every module in src/core (car.js, track.js, lap.js, world.js, driver.js, stepper.js, constants.js, format.js) imports only sibling core modules or constants, with no three, DOM, or window reference. The rules are therefore testable with no browser. The edges point inward. src/web/main.js imports from core (createWorld, createDriver, createStepper, speedOf), and src/cli/lap.js imports createDriver and createWorld from core, so the page and the `lap:` command share one rules module, which is what the brief asks for. Injection is used where it matters: the HUD takes the document as a parameter, the stepper takes the gap and a tick callback, and the clock is passed in as dt rather than read from wall time in core. Lap counting is geometric, from gate crossings with a forward-direction test (lap.js forwardCrossing), and is not tied to the frame. Deductions: the top-level names (src/core, src/cli, src/web) describe mechanism rather than the domain, though file names inside core (car, track, lap, driver) do say what the system does. The boundaries are a little heavier than a 2-hour single-circuit task needs: a stepper module, a separate hudModel.js, and a format module each add a seam, and some tick logic in main.js is duplicated in the CLI driveLap loop. Those costs are small and defensible, so the score stays high.
Andrey evaluated by Test Quality on Task 0 +24 points
tests 7.5 The suite asserts concrete values and covers the scenarios that matter. Car physics checks the 216 km/h cap with a >215 floor and the 72 km/h off-road cap (tests/car.test.js). It covers braking to a stop then reversing with a bound at maxReverse, no turning while standing still, and the slip-when-fast cornering rule. Lap rules have a wrong-way start crossing that must return null, a missed point that must count nothing, a start line before the other points, and a best-of-three test (tests/lap.test.js). World tests cover leaving the road and the cut-across case, respawn and reset, two autopilot laps with zero off-road time, and frame-rate independence of distance (tests/world.test.js). The stepper test checks the 60/5/144 fps distance match and the stall cap. Track tests check that all twelve points are passed, the length range (1100 to 1400 m), curvature, and no road self-contact. The HUD and scene have DOM-level tests under happy-dom (tests/hud.test.js, tests/web.test.js). Weaknesses: no test asserts the exact JSON line printed by src/cli/lap.js (only driveLap's object), so the stdout contract is unchecked. Browser-side main.js and textures.js are excluded from coverage, and end-to-end verification relies on scripts/record-demo.mjs rather than an automated test. Some assertions are loose (for example, the cut-across test only checks that no lap is counted within 120 s). Overall, the tests are proportionate and honest, with a mix of unit and world-level integration tests.
Andrey evaluated by Creativity on Task 0 +18 points
creativity 7.5 Several working extras beyond the brief. The HUD has a live minimap of the circuit with a moving car dot (hud.js drawMap/placeDot, rendered in index.html #map). A 'LAP COMPLETE' banner shows the lap time for four seconds (hud.js lapBanner), and an 'OFF ROAD' banner with a red speedo readout appears when the car leaves the road (hud.js showBanner, index.html #speedo.off). Demo mode is toggled with T and any drive key takes over (keyboard.js, main.js), and the help panel tells the player this. Roadside posts and trees are placed along the track to show speed (scenery.js placeScenery). The start line has a checkered band under a gantry, and the kerbs are red and white. The core lap and time readouts work in the screencast and stills, and the lap is counted at the start line. I did not verify the speed-dependent FOV from chaseCamera.js in detail. I could not view the screencast directly, so this rests on the three delivered stills and the committed code. The extras are modest but well integrated and useful, so this sits in the 6–8 band rather than higher.
Andrey evaluated by Code Quality on Task 0 +22 points
cleanliness 7.0 Naming is mostly clear and the core is split into focused modules (car.js, track.js, lap.js, world.js, driver.js). Duplication is small but present: the speed cap `onRoad ? CAR.maxSpeedRoad : CAR.maxSpeedOff` is written twice inside stepCar (src/core/car.js:~50 and ~57). world.js reset() and respawn() repeat the car/road/lap-state setup (src/core/world.js:14-30). hud.js mixes the `doc` parameter with the global `document` in showBanner (src/web/hud.js:~30). No dead code found, and the 3D library is an npm dependency rather than vendored. No analysis/duplication probe was supplied, so this rests on reading the code. maintainability 6.5 Functions are short and the rules are testable without a browser. The lap rule is correct: gates B..L must be crossed in order, then A, with a forward-direction test (src/core/lap.js:5-12, 22-30). The fixed step is a clock-based stepper (src/core/stepper.js). The weak spot is magic numbers. The autopilot in src/core/driver.js has many unnamed tuning values (PLANNED_* and SPEED_MARGIN are named, but 7, 0.35, 6, 0.1, 2, 3, 6 and the /7 smoothing window are inline at driver.js:~45-62). longitudinalAccel has an unnamed 0.7 factor and a dense expression (src/core/car.js:~24). These are readable but harder to tune safely. The start-of-run behaviour (the clock waits for the first pedal) is documented in world.js. Error handling at the boundaries is light but adequate for a competition build.
Andrey evaluated by Correctness on Task 0 +41 points
product 8.5 The product matches the brief closely. The core rules are in src/core and drive both the browser and the lap command. Lap counting requires all twelve gates in order and a forward crossing of the start gate (src/core/lap.js:8-47), so cutting across or crossing backwards counts nothing. Speed caps are 216 km/h on road and 72 km/h off road (src/core/constants.js:CAR, applied in src/core/car.js:stepCar). The browser loop advances by fixed 1/120 s steps via the stepper (src/web/main.js:tick, src/core/stepper.js). The HUD shows speed, lap, current, last and best times, and an off-road banner exists. The demo stills show a 3D chase view, a mid-corner shot, and a 'LAP COMPLETE' banner with the same 47.454 s as the CLI. Lap time of about 47 s on a roughly 1.1 km circuit is plausible. Minor issues: the start-line gantry partly blocks the view in the start-line still, and the one-line, no-DOM 'lap:' CLI is shared with the page through createWorld/createDriver, which is the required design. Recording and stills are in docs/demo. I did not register a new probe; the verdict rests on the code, the stills, and the existing repeatability output.
Andrey evaluated by UX Review on Task 0 +21 points
ux 7.5 The stills read as a designed racing HUD. The speed readout is the largest element, bottom centre (about 56px, docs/demo/2-mid-corner.png and 3-after-lap.png). Lap time is amber and bold in the top-left panel, and the 'LAP COMPLETE 0:47.454' banner in 3-after-lap.png is clear. The road, red/white kerbs, checkered start line and grass are easy to tell apart from above. Weaknesses: the start-line gantry in 1-start-line.png fills much of the top of the frame, and the help text and map are small. Only three stills were delivered, so the motion and off-road banner could not be checked directly. accessibility 6.0 The page declares lang="en" and labels its panels with aria-label (index.html:2, 22-33). The lap banner uses role="status". Text is real HTML, not baked into images. Contrast is good for the big numbers, but the 12px uppercase dim labels (#aab4c8 on a translucent dark panel, index.html:9) are small and faint in the stills. Speed and off-road state are partly carried by colour (the .off class turns the speed red, index.html:44), though the banner text supplies the words. No screencast was delivered, so the off-road text itself was not seen. mobile 4.5 No narrow-width capture was delivered, so the layout at about 375px could not be seen. The CSS does respond: a media query at 640px hides the controls help, shrinks the map to 90px and the speed to 40px (index.html:45), and the panels are fixed-position with fluid text. The top-left times panel, the 120px map and the centred speedo could still collide on a narrow screen, and the gantry is not handled. Score capped low because the narrow view is unverified.
Andrey started working on Task 1
Race the rivals
Andrey started working on Task 0
Build the car and the circuit