Skip to content
Fyndi docs
Polski

Quality and checks#

Quality here is measured on numbers rather than judged by eye, because the character creator breaks in ways a single screenshot cannot show: an element shifts by 0.1 of a unit and pokes through an arm in one animation but not in another.

Gates and checks#

All of these run on the same code that goes to production — not on a mock-up.

ToolWhat it checks
check_props_parity.pyparity of the tables: identical blocks, zones, colours and palettes in the website version (JavaScript) and in the app (Kotlin). Any drift would mean a different look on the phone and on the web
run_anim_audit.pypushes the character through every animation clip and measures real intersections of blocks in 12 outfit sets
check_gaps.pythe opposite of the collision audit: no accessory may float — every block has to touch the body or the item it is attached to
film_strip.pyreturns a strip of frames from an animation, for judging movement rather than a single pose
dump_atlas.pydumps the character atlas to a PNG, so the painting can be looked at without guessing what is where
bash scripts/ci-server.shrepository checks: tools and paths present, Python and JS asset syntax, conflict markers, and the Android JVM tests (:core, :ar, :app)
android-compile-guard.pya static audit of the Android code before a release: missing imports, name clashes, calls to suspending functions from places that must not wait. It catches classes of errors that would otherwise cost a full APK build round
glsl-check.pycompiles the map layer shaders in a real WebGL2 context and checks that every parameter is used — this is how a bug that switched off all figures on the map was found
tools/perf/run.shmap performance: cost per frame, number of draw calls, behaviour from one pawn → plus finds → plus a route → plus players → plus bots
marker and bot testsparity of markers and bots between the website and the app (the same sizes, thresholds and colours on both sides)
shoot_legend.pydocumentation screenshots taken from the real code, checking for each marker whether it is in frame, whether the layer drew it and whether it is actually visible in the image

The checks are arranged in layers, so a broken change is caught as early as possible — but each layer is started by hand; nothing runs on its own when code is pushed:

  1. Repository hygiene — bash scripts/ci-server.sh checks that tools and paths exist, the syntax of Python and JS assets, conflict markers and the Android JVM tests (:core, :ar, :app). A red test stops the work.
  2. The documentation gate — tools/ci/check-user-docs.py checks the site structure, images, links, the PL/EN parity and that every option from the settings catalogue is actually described.
  3. Before an APK release — scripts/build_release_apk.sh checks the version number, signs the APK with the release key, verifies the content gates (ARCore key, Mapbox token), runs the ART smoke test on the emulator (AVD) and proves the published file over HTTPS (APK releases).
  4. On production, without a phone — after a deployment, verification runs against the live API: that the pages exist in the brain graph, that screenshots load in the panel, and that new rules behave in the real service rather than only in a test.

The pre-push hook and the repository-wide aggregate gate were removed on 15 October 2026 (process cleanup), so a push no longer triggers any check — the commands below are the whole gate.

How to run the checks#

Everything is a command in the repository, so a result can be reproduced by anyone:

bash scripts/ci-server.sh               # repository hygiene + JVM tests :core :ar :app
python3 tools/ci/<gate>.py --self-test  # proof that a single gate can go red (mutations)
python3 tools/ci/check-user-docs.py      # the documentation gate (structure, links, assets)
python3 tools/ci/check-user-docs.py --self-test   # proof that the gate can go red
bash scripts/build_release_apk.sh        # the whole APK release: tests, build, gates, publish
bash scripts/deploy-docs.sh --check      # report drift between repository and server, changes nothing

The full animation audit needs a local lab server and a directory with the drawing scripts, so it is run deliberately (before a change that touches the character), not on every edit.

What the documentation gate watches#

The gate does not judge writing style. It enforces structure, so that “the documentation is up to date” can be checked by a machine instead of promised:

#Rule
1every entry in the feature list has a page in both languages, and its anchor exists in both
2every image referenced by the list or by a page really exists on disk
3every internal link points to a page and an anchor that exist
4no orphan pages: every page is listed in the site tree
5every option from the app's settings catalogue has a description — the only rule that forces content to be current, not merely consistent
6the Polish and English site trees have the same pages
7a scan for secrets and server addresses in published content — it blocks
8every page has a version footer and no leftover placeholders
9in release mode: the version in the feature list matches the version in the Android build file
10the documentation stylesheet has no trap that would silently cut a rule

--self-test deliberately breaks things and requires that each mutation turns the gate red — a gate that has never failed proves nothing.

Verification on a device#

Some things can be verified without a phone; a few cannot, and it is honest to say which is which.

WhatHow
Map logic and markerspure Kotlin: 95 of 95 checks — sizes, zoom thresholds, marker hits, bot labels
Map performancethe harness reports OK with 72 tests; three bots cost +1 draw call per frame, and marker layers add 0 style sources and 0 style layers
Markers on the website224 of 224 — sprites, palette, thresholds and state order match the app
Android code before releaseclean: no missing imports, no blocking calls; 8 shader programs compile and link in WebGL2
Map legend screenshotsall good: every marker visible in the image, zero circles drawn on the map
Character auditgaps OK — 83 blocks in 60 sets, nothing floating; the largest in-motion intersection was 0.085 of a unit inside the silhouette and therefore invisible

What a desktop verification cannot replace:

  • the AR view — it needs Google Play Services for AR, so it does not start in an emulator; those frames are judged on a real phone, by the owner;
  • visual taste — the animation strip and renders are for the eye; the numbers only say whether anything intersects;
  • the true look on a specific device — screen size, brightness and performance are the phone's, so a measurement is always paired with a real-device check before a release is called done.

Documented for app version 0.357.3 (updated 2026-11-12).

Machine translation — the Polish version prevails.

App version: 0.357.3 API version: 0.73.0

docs.fyndi.app · 2026-11-12