The Shot
A live crowd game · Powered by Touch Crowd Systems (TCS)
What if halftime wasn't something the crowd watched — but something the crowd played?
A concept video: the arena, the crowd and the game are a visualization. The Shot is in construction.
Building The Shot
We're building The Shot as a live crowd game with Touch Crowd Systems (TCS).
Thousands of people join from their phones, split into two teams, take on different roles, and together influence a basketball game unfolding live on the arena screen.
But the interesting part isn't only the game. It's how you make thousands of individual actions feel like one shared experience.
This is how we're building it.
First ideas
We're in the middle of building it, and this page follows the work: each step is a decision we made, something we built to check it, or a question still open.
How we are building it
Start with the crowd
We didn't want a game where a few people play and everybody else watches. So the first constraint became the most important one: the crowd is the controller.
People join from their own phones, with no account to make and nothing to set up. Each grandstand is a team — Blue on one side, Purple on the other — and the arena screen becomes the shared game world.
Your part of it stays yours. Your phone keeps its own record of what you did, it ends with the event, and there is no account to close because there was never one to make.
Give everyone a role
Thousands of people tapping the same button isn't much of a game. So we split each team into roles, and your phone only ever shows you yours.
When your team attacks you might Lift, Aim or Shoot. When it defends you might Block, Deflect or Charge. At the next turn your phone can hand you a different one.
That's what lets you be part of the same team without everybody doing the same thing.
Attack
- Lift
- Aim
- Shoot
Defence
- Block
- Deflect
- Charge
A role is more than a label
A role changes what your phone can do. A player given Lift doesn't have the same actions as one given Aim or Shoot. On defence, Block, Deflect and Charge expose a different set again.
And those capabilities aren't permanent. When the turn changes, the same phone can be given a different role — and with it, a different set of actions.
That's one of the things we're building The Shot to test: thousands of participants in the same game, without requiring every participant to be capable of the same things.
Participant #4281 Turn 1
Attack
Aim
Guide the shot
Turn 2
Defence
Block
Raise the defence
Same participant. Same game. Different capability.
The six roles in the model, three to a team, with two phones showing what their holder was dealt this turn. Left and right are the two grandstands. Turn thousands of actions into one
A single phone doesn't control the ball. Hundreds of people may be aiming; hundreds more may be trying to deflect them. What happens on the screen is those two crowds meeting.
In the model a turn resolves as one number per role against the other side's: Lift against Block decides how high the ball goes, Aim against Deflect where it ends up, and then the shot is taken.
Different capabilities, one result
The crowd doesn't need to be uniform for the game to behave as one.
Each participant contributes only through the capability they currently have, and the game combines those different contributions when the turn resolves.
So the shared result isn't produced by thousands of identical clients sending the same action. It's produced by a population of participants doing different things at the same time.
Make the arena react
Two surfaces, carrying different halves of the same game. Your phone gives you one instruction, small enough to follow without missing what's happening; the big screen carries what everybody did together — who's attacking, how each role went, the score, and the shot.
The only thing you have to understand is the one on your own phone.
Build a model we could watch
Before worrying about a real arena, we built the smallest thing that could tell us whether the rules hold together at all. It isn't a game you can play: it's a full four-turn match you can watch, step through and rewind.
Enough to answer what we needed to ask at this stage — can both sides act inside the same turn, can roles change between them, and does a turn read at once from a phone and from the back of an arena.
A turn resolving. The screen carries the six bars and the score; the two cards are what one person on each side is holding. The percentages are a worked example, not a measurement — nobody has played this. Put it in the arena
A model on a laptop can tell us whether the rules make sense. It can't tell us what a full arena feels like — so we're building that view too, putting the same moments inside one, to see whether the game still reads from the back row.
That's the video at the top of this page.
What we're building next
One format. Any sport, any event.
The Shot isn't a basketball game. It's a crowd format, and the play is shaped around whatever is happening in the building.
Swap the six roles and the same system runs a different sport. What doesn't change is everything that makes it work: the crowd is the controller, everyone holds a role, and thousands of separate actions land as one moment on the big screen.
| Side | Basketball | Soccer |
|---|---|---|
| Attack | Lift | Build |
| Aim | Aim | |
| Shoot | Shoot | |
| Defence | Block | Press |
| Deflect | Block | |
| Charge | Save |
Same format. Different sport. Same moment — your phone says SHOOT, you tap, and the whole building watches one ball.
That portability isn't a feature we bolted on. It's what you get when a role is a capability a participant holds, rather than a screen we drew for them — change the capabilities and the game changes with them, while everything underneath stays exactly where it was.
First ideas · soccer
Even the two sides travel: in the soccer version the grandstands are orange and green. Basketball is the version we're building first.
The chapters after this one
The road from here, in the order we expect to build it. Each of these becomes a step above when there is something to show for it.
Give each player its own state
The model could fake a crowd; this can't. Every phone becomes an independent participant that knows its team, the role it holds and what it has already done — thousands of small ones instead of one large object standing in for a crowd.
Connect them
How much has to reach anyone at all for a turn to resolve.
Put thousands together
The measurement everything rests on.
See what happens when connections fail
In an arena they will. Whether the turn still resolves, and what the game does about the people it couldn’t hear.
Take it to an arena
With people. Everything above is preparation for this and none of it substitutes for it.
What it's built on
Not the first thing we've asked a room full of phones to do together.
The Village Hall
A bingo night running entirely on the phones in the room: no server holding the messages, no database holding the night.
The Village HallPuppeteer
The substrate underneath: software subjects that carry their own identity, authority and history.
PuppeteerThis page grows as the work does. What's here is what we've decided, what we built to check it, and what we still don't know.
Same game. Different participants. Different capabilities. One shared result.