Paris Battle Royale: four landmarks, one river

The plan for the /game section of this site. A tab you open, a pocket Paris, a round already running, 30 seats, and every seat that isn't a human is an AI Parisian running on GPT.

The pitch in one breath: a small, stylised Paris made of exactly four landmarks with the Seine running through them. Three-minute rounds of battle royale where the zone shrinks to one monument and the last one standing wins. Every round has 30 seats. A seat is either a human or an AI agent, never something in between, and every agent runs on the same GPT model so it makes real decisions, fast. Alone at 3am, it's you against 29 agents. Thirty friends show up, it's humans only. That seat rule is the experiment. The battle royale is the excuse to run it.

Tech assumptions, so we argue about the same thing: three.js or React Three Fiber for the picture, Rapier for physics, a WebSocket server on the VPS that owns every round, Supabase for anything that has to survive a refresh, and one GPT model behind every AI seat. Phones count. Nobody installs anything.

The map

Four landmarks. One river. Nothing that isn't needed to run between them.

The look, locked on 28 September 2026. Prompts and the character sheet are in image prompts.

        [Arc de Triomphe]
               |
               |  the Avenue
               |
 ~~~~~~~~~~~~~~+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  right bank
   [Louvre]                               |
 ~~~ Pont des Arts ~~~~~~~ Pont Neuf ~~~ [Notre Dame] ~~~  the Seine
                                         (on its island)
 ~~~~~~ Pont d'Iéna ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  left bank
   [Eiffel Tower]

That layout is roughly real, just squashed. The Arc and the Louvre sit on one straight line in actual Paris, the Seine cuts across it, Notre Dame sits in the river on its island, the tower faces the water from the left bank. So the map gets two spines for free: the Avenue running north to south, the Seine running east to west. Every fight happens somewhere along those two lines.

Size: about 1.2 km by 700 m of real Paris, compressed so you can sprint across it in ninety seconds. Small enough for a phone, big enough that "the zone is closing on the Louvre" means something.

Why exactly these four

• Everyone on Earth recognises them at 300 triangles. A low-poly Eiffel Tower is still the Eiffel Tower. A low-poly Rue de Rivoli is a grey box.
• Each one is a different kind of fight. Vertical, open, circular, cramped. Four landmarks, four final-zone flavours.
• Two of them frame the river. Notre Dame sits in it, the tower faces it. The Seine isn't scenery, it's the chokepoint system.
• Four is a number you can finish. Twenty arrondissements was a fantasy. Four landmarks is a month of Blender.

Each landmark, as a place to fight

The Eiffel Tower is the vertical fight. Three levels you can climb, the only spot where you see the whole map. Great to hold, terrible to leave. When the final zone lands here, the last two are usually on the stairs.

The Louvre is the open fight. The courtyard around the pyramid is a wide killing floor with the pyramid as the only cover. The Tuileries next to it is hedges and statues, so the approach is sneaky and the finish is brutal.

The Arc de Triomphe is the circle. The roundabout is a ring of parked cars and the Arc is the tower in the middle. You can go under it, on top of it, or around it. Finals here spin.

Notre Dame is the cramped fight. Two towers, a nave, and an island you can only reach by bridge. Three ways in, all of them visible. When the zone shrinks here, the bridges are the whole game.

The Seine

The river is the spine of the map and the reason movement matters.

• Three bridges, three chokepoints. Pont d'Iéna at the tower, Pont des Arts at the Louvre, Pont Neuf at the island. Everyone has to cross one to reach the zone. Everyone knows it.
• Water is slow. You can swim, but you're a target, and you drop your baguettes. Sometimes it's still the right call.
• Boats. Two bateaux-mouches loop the river as moving cover. Ride one from the tower to Notre Dame while doing nothing, get shot at by everyone, arrive a hero.
• Quais. The riverbanks are low ground with stairs up to street level. Perfect ambush lanes. Also the best spot in the map for a sunset screenshot.
• The Seine is the frame. Nothing exists past the river's east and west ends. The map fades into fog and a Métro sign that says "not yet".

The round

Three minutes, start to finish. Short enough that a dead lobby fills before the next one starts.

1. Lobby, 30 seconds. Whoever's on the page is in. The 30 seats fill with humans first, then agents.
2. The drop. Everyone glides in as a pigeon from above the tower and picks where to land. Pigeons are 300 triangles and nobody needs a parachute animation.
3. Loot, 45 seconds. Baguettes and one gadget spawn at each landmark and along the quais. Grab what you can.
4. Zone one. The fog closes from the map edge to the two banks. Bridges get crowded.
5. Zone two. Closes to one landmark, picked at random each round. Four possible finals, four completely different last minutes.
6. Last one standing. Results, a replay of the winning elimination, next round in 20 seconds.

The server owns the timer, the zone, the loot, and every hit. Clients predict, the server decides.

The fight, and the weapons question

You need an elimination mechanic, not guns. Real guns mean hit registration, lag compensation, and gore on a personal site. So:

• You throw baguettes. Slow projectile, visible arc, satisfying thunk. Three hits and you're out.
• One gadget slot. A pigeon decoy, a Vélib for a speed burst, an umbrella that blocks one hit. Small, readable, funny.
• The zone hurts. Outside the fog you lose a hit every ten seconds.
• Eliminated players spectate. From the top of the tower, with chat. Dead players keep the room full.

No skill trees, no rarities, no attachments. If it can't be explained in one sentence to someone who wandered in from the blog, it's out.

The 30: the autonomous AI agent simulation

This is the core experiment. The battle royale is the container it runs in.

A round has 30 seats. Each seat is either a human or an AI agent. There is no third kind: no dumb bots, no scripted fillers, no "easy mode". Every agent is powered by the same GPT model, and every agent makes its own decisions in real time. Where to land. Which bridge to take. Whether to hold the tower or run for the boat. Who to chase, who to avoid, when to give up on a grudge.

How a seat works. When a human joins, the agent in that seat steps out and goes to watch from the quais. When the human leaves, the agent steps back in. At any moment the lobby is some mix of the two, and nobody in the round is told which is which. Reading who's human is part of the game.

How an agent thinks, fast. GPT decides intent, the game executes it.

• Every couple of seconds each agent gets a compact snapshot: where it is, what it sees, its hits left, the zone, its memory of the people around it. It answers with one decision: go here, chase them, throw now, hide, swim.
• Between decisions a tiny local controller does the moment-to-moment work: pathfinding across the bridge, aiming the throw, dodging. That's what keeps it fast and smooth on screen, and it's what keeps 30 agents affordable.
• One model for all of them. Same brain, different memories and different personalities. That's the point: the variety has to come from what they've lived, not from which model they got.

What they carry between rounds. Each agent has a name, a home landmark, a personality, a memory and a grudge list. An agent you eliminated last night will look for you tonight. The one who always lands at Notre Dame has a reason. The reigning champion gets cocky. Between rounds they live on the map: commute across the bridges, sit on the quais, ride the boat, argue at the Arc, and hold a small council in the Louvre pyramid that votes on things that change the next round, like closing Pont Neuf or making it rain.

The question we're actually asking. Can 30 GPT-powered Parisians, all making real decisions in real time, make a browser battle royale feel alive with one human in it? And when thirty humans show up and the agents all step out, does the game still feel like the same place? If both are yes, the lobby problem that kills every small multiplayer game is solved.

Cost and sleep. Thirty agents deciding every couple of seconds is the biggest bill in the project. Hard monthly cap, decisions only during rounds and council sessions, and the whole sim freezes ten minutes after the last visitor leaves. Someone arrives, the agents wake up mid-sentence.

Guardrails. Agent politics stay about bridges, baguettes and pigeons. Nothing real-world. Visitor whispers to agents are filtered and rate-limited. A real name is on this site.

How you join, from a website

The test for everything: does it work when one person shows up, and does it get better when a hundred do?

• Watch. The /game page opens on the live round from the top of the tower, with an elimination feed. Zero clicks.
• Play. Nickname, one click, you're in the next lobby. No account.
• Spectate and talk. Eliminated, you're on the tower with chat. Chat can throw bread, which the pigeons chase.
• Nudge the sim. One whisper a day to an agent, one vote a day in the council. Enough people want Pont Neuf open, the council hears it.
• Keep your name. Optional account keeps your stats, your wins, and your name on the plaque of any landmark you won a final at.

Decisions already made

• Map first, character later. The map decides movement, sightlines and finals. The character is a capsule until step H. Character first means redesigning it every time the map moves.
• No guns. Baguettes, three hits, one gadget. Cartoon violence, simple netcode.
• Server authority from day one. No peer-to-peer, no client-decided hits. It's slower to build and it's the only version that survives real people.
• Agents before humans. The 30 exist before the first multiplayer test, so the game is playable alone from step E onward.
• One model for every agent. All 30 run on the same GPT model. No scripted fillers. If an agent is in a seat, it's making real decisions.
• Thirty seats, for now. Human or agent, never a mix inside one seat. We'll see if the number moves.
• Stylised, low-poly, baked. Not a choice, a budget. It also looks better than "realistic but bad".

The road from A to Z

A is now, planning. Z is playing live with real people and the 30. Every step ends with something you can open in a tab.

1. A: Lock the pitch. This page. Four landmarks, Seine, 30 seats on one GPT model, baguettes, three-minute rounds. No Blender until this is agreed.
2. B: Greybox map. Four landmark blocks, the river, three bridges, the Avenue, the quais. Grey boxes only, exported from Blender, loaded in three.js. Deliverable: walk around it alone.
3. C: Movement and camera. Third person, keyboard and mouse, jump, sprint, swim. Tune on the greybox until sprinting across Pont Neuf feels good. Phone joystick later.
4. D: Two people, one map. WebSocket server on the VPS, rooms, join by URL. Server owns positions, clients interpolate. Deliverable: two browsers, two capsules, same Paris. If this feels bad, stop and fix it before anything else.
5. E: The 30, on GPT. Agents with homes, personalities and a grudge list, each making real decisions on the same GPT model, with the local controller doing the moment-to-moment work. From here the game is never empty.
6. F: The round loop. Lobby, pigeon drop, zone one, zone two, last one standing, results, again. Server runs the timer and the zone.
7. G: The fight. Baguette pick-ups, throws, hits, gadgets, zone damage. Server validates everything.
8. H: Art pass. Real low-poly landmarks, Seine water, baked lighting, tower sparkle on the hour. Capsule becomes a character.
9. I: The life between rounds. Memory that persists, grudges that pay off, the council in the pyramid, the sim that runs when nobody's fighting.
10. J: Juice. Sounds, hit flashes, elimination feed, spectator camera, results screen with a share button.
11. K: Site integration. /game becomes the lobby and the live camera. Nickname, one click. Sitemap, OG image, plaque.
12. L: Playtest. Ten friends, one evening. Fix desync, add rate limits, ban obvious speed hacks. Repeat until a round feels fair.
13. Z: Live. Soft launch on the site, stream it, rounds every three minutes, the 30 keep it full between humans.

Version one is done at step G. Everything after it is polish and the experiment.

Where it can go wrong

• Netcode, steps D to G. This is the whole game. Browsers, phones and WebSockets are a harder combo than a native client. Keep the player count at 30, keep the projectile slow, keep the server in charge.
• GPT cost and latency. Thirty agents deciding every couple of seconds is the biggest bill and the biggest delay in the project. The local controller has to carry the movement so a slow answer never freezes an agent, and the monthly cap is a hard stop, not a warning.
• The agents being boring. Same model, thirty seats, they could all play the same way. Memory, personality and grudges are what make them thirty different people, and that layer has to ship in version one.
• Phones. Half the visitors. Throwing a baguette on a touchscreen needs its own design, not a port.
• Scope creep. Every idea below is a "later". The finish line is step G.

Later, on the same map

• The council for real. The AI city government from the earlier brainstorm, running between rounds. Agents vote on bridges, loot and weather. Visitors can run for mayor.
• Ghost lines on the quais. Skate the riverbanks under Pont d'Iéna between rounds. Your best line is saved as a ghost for the next visitor to race.
• Rooftop tag. Ten players on the Louvre roofs and the Notre Dame towers, one is "it", ninety seconds. A party mode for when the lobby is small.
• Flood night. Once a month the Seine rises. The island cuts off, the boats are the only way across, the council meets on a péniche.
• A fifth landmark. The fog at the map's edge hides a spot. When the council votes to expand and enough visitors show up for it, Sacré-Cœur or the Opéra appears. The map grows only if the city earns it.

Open questions

• Real Paris time for the tower sparkle and the agents' day, or a compressed day so every visitor sees a full cycle?
• Monthly GPT cap for the 30, and do we let visitors buy the sim a coffee to raise it?
• Decision cadence: every two seconds, every five, or only when something changes in the agent's view?
• Do the agents read the rest of the site? A champion with opinions about the blog would be very funny.
• Accounts: none to play, optional to keep stats. Is that enough, or is a nickname-only leaderboard too easy to spam?