RDE | KONTRAKT

KONTRAKT is a top-down open-world RPG about a hired killer in a city that lives on its own. People keep daily routines, traffic follows the lanes, police respond to emergency calls instead of knowing everything, and the city cleans up after you on a believable clock. You decide how to make your money: quiet contract work, bank heists, a protection racket, a drug business, a legal bar or all of it at once.

The same game runs alone in your browser and on a multiplayer server. Online, the city belongs to everybody: every house has at most one owner, gangs fight over the same blocks, crews guard their bosses' places while they are offline, and players take the ferry to other cities.

The game is written in plain JavaScript without a framework, engine or build step. Its simulation does not touch the DOM, so exactly the same code runs the singleplayer game in the browser and every city on the multiplayer server. The server is Node.js with built-in modules only: its own WebSocket server, its own MariaDB driver, its own migrations.

• Authoritative server: the simulation runs only on the server; clients send their inputs (one per 60 Hz step, acknowledged by number) and draw what they are sent.
• Every city in its own worker thread (GAME_WORLDS=raven,aurelio,ironhaven). A thread that dies or hangs is restarted by a watchdog; the other cities keep playing.
• Network workers (by default the number of cores minus two, one to eight) build each client's snapshot — actors, cars, events and the JSON — so the simulation thread only produces one frame of changes per tick.
• The main thread never touches a world: it handles WebSockets, accounts, the database and the panel, and writes finished snapshot strings to the sockets.
• Per-player passes: every NPC and car has a focus player; systems run once per player context and only update what is theirs, so a guard can arrest one player while growing suspicious of another.
• Car radio server in plain Node: every folder in radio/ is a station, rescanned every 30 seconds (links and junctions included); only new or changed files are read, and only their first 64 KB — the ID3 tag for title and artist, the first frame (Xing, VBRI or constant bitrate) for the length.
• A station clock instead of a stream server: each station has a fixed order shuffled by its name, and the position is the time since a common epoch modulo one round. Every client works out the same second by itself; the server only serves files, with HTTP ranges, ETags and a day of cache, and nothing outside the songs.
• Manager process supervises the server, restarts it after a crash and ships with a systemd unit.

• 20 snapshots a second per client, spread over the three ticks of the cycle so no single tick carries all of them.
• Deltas only: each client gets what changed around it — doors, props, lights, items, glass and small lists only when they change.
• Dead reckoning: position, heading and velocity go out together only when the client's extrapolation would be off by more than 1.5 px, 0.05 rad or after 18 ticks.
• Client prediction for walking and driving with the same physics as the server, reconciled against the acknowledged input; small errors are eased in, large ones snap.
• Predicted street furniture: a lamp your car hits goes down on your screen in the same frame as on the server, so you drive through instead of bouncing off.
• Backlog control: a client whose socket backs up gets fewer snapshots instead of stalling the server, and its inputs are paced so nobody is pulled back.
• Shared lists for what everybody sees: windows, puddles and piles on the street go out as small lists only when they change; car state such as the horn, the radio station, the lock and the alarm rides along with the car.
• Held keys (E, T and the horn on H) travel with every input, so a horn sounds for exactly as long as the key is down on every screen.
• Version handshake: a page running older code reloads itself; a client always builds the city its character is in.

• Capacity grows with every city: cities share nothing but a once-a-second gang sync, so each one adds a thread's worth of players. On a server, plan one free core per city plus the network workers.
• Hot-path work: spatial rasters for actors, cars, doors and players, compiled per-snapshot preparation, fast object shapes, LOD for far-away pedestrians, a shared police budget for the whole city.
• Saving off the hot path: characters are saved in portions (one round every 30 seconds instead of one big hitch), the city state once a minute.
• Profiler in the panel: the server times its systems on every eighth tick and shows the cost of AI, cars, police, players and more live.

• A profile check verifies every city before it is built: size, district map, seafront, block plans only where they will be built, and every shop and office the game needs.
• Port Raven never changes by accident: every release is compared against the previous one with a behaviour fingerprint of a full simulated session; the city stays identical tile for tile.
• Building layouts as block plans: factories, churches, town squares, market halls and stations are block types with their own interiors, props and staff. New steps are only ever appended to the generator, so a city with none of them keeps every tile and every number it had.
• Post-build checks: windows that meet an inner wall become wall, and a piece of furniture that would cut off part of a room is not placed at all, so every floor tile stays reachable.
• Map overlay: admin edits (a tile, street furniture removed or added) are a list on top of the generated city — saved with the world, laid over the city on every start and sent to the clients. Every edit remembers what was there, so a stroke can be undone with its exact inverse; strokes are numbered in the saved list, an undo works across restarts, and a reset compacts the list when the world loads.
• Travel hand-off: the server saves the character, makes the destination its home world, and the client reloads with the other city. What belongs to a city is parked per city in the character's state and comes back on return.
• Gangs across worlds: each gang has one home world that alone changes it; every other world holds a read-only copy refreshed once a second, so a treasury can never be spent twice.

• Overview: start, stop and restart, players in the city, simulation step, load, memory, uptime, database pool.
• Live map of every city with a world switcher: players, NPCs, cars, turf and houses; right-click to teleport.
• Live map editor: paint tiles with a brush, put down and remove street furniture, undo stroke by stroke (Ctrl+Z, even after a restart) or reset the city to how it was generated. Every change is live for all players at once and saved with the world.
• Real estate: every property with owner, upgrades, furniture and who is inside; evict or hand over.
• Metrics: history charts and the live system profiler.
• Players and tools: kick and ban, heal, give items, weapons and money, set or clear wanted levels, release from jail.
• World control: time, weather, broadcasts, clearing traffic and wrecks, street-life density; live log.

• Baked ground chunks (8 × 8 tiles) with procedural textures, ambient occlusion and decals for blood, bullet holes, scorch marks and skid marks.
• Lightmap composited with multiply: lamps, windows, neon, headlights, muzzle flashes, fire and the helicopter's spotlight.
• Line-of-sight fog from a visibility polygon cast 30 times a second; roofs fade per building.
• WebGL2 post-processing: bloom, chromatic aberration, grading, instinct vision and grain; dynamic resolution holds the frame rate.
• Vector sprites for people, weapons, cars, furniture and street props — no image assets. Sawtooth factory roofs, church roofs and glass halls, chimney smoke plumes, trains, pews and market stands are drawn the same way.
• Street mess drawn per frame: the pee stream as an arc from the character, puddles with a wet sheen, steaming piles with flies, sick, and brown footprints from whoever stepped in it.
• Audio without assets except engine recordings: a generative synthwave score, venue music, physically modelled gunshots, Doppler sirens and spatial ambience. The horn is a continuous voice of three reeds with saturation and an echo off the facades, held as long as the key.
• Car radio in the browser: each radio is an audio element routed through Web Audio (low-pass, gain and panner), so nothing is decoded on the game thread. At most three play at once — yours and the two nearest cars, muffled and panned — checked four times a second and re-synced only when they drift by 2.5 s. Your radio ducks the score; breaks without mp3s get a synthesised three-note ident and the browser's voice for the presenter and the adverts, in English or German.

• Every city is built and played for a simulated minute in the test suite; the whole suite can run inside any city.
• Changes in behaviour are proven: when a feature is meant to change Port Raven's fingerprint, it is switched off once to show that the old fingerprint comes back, and the new one is logged.
• Tests that need nothing: the radio test writes its own little mp3s, the bladder test builds its own quiet city, so no test depends on music files or on what the live city happens to do.
• Translations: English source texts, German generated from translation parts and checked for missing keys and placeholders.