/* ══ city ════════════════════════════════════════════════════════════════
 * The place itself: the banner at the head of the tab, the market you can put
 * money into, and the buildings that stand in it.
 */

/* ── the banner ─────────────────────────────────────────────────────── */
.city-banner { display: grid; gap: 14px; padding: 18px; }
.city-head { display: flex; align-items: center; gap: 12px; }
.city-head > div { min-width: 0; }
.city-name { font-family: var(--font-display); font-size: 21px; font-weight: 600;
  color: var(--text-hi); }
/* Wider wells than the character card's, and the figure bigger still: this is
   the headline block of the tab rather than a footnote on a sidebar. `.fact`
   itself is in `character.css`. */
.city-stats { grid-template-columns: repeat(auto-fit, minmax(140px, 1fr)); gap: 9px; }
.city-stats .fact { text-align: left; padding: 11px 13px; border-radius: var(--r-md); }
.city-stats .fact b { font-size: 19px; }
.city-stats .fact span { font-size: 10.5px; }
/* Which way a number moved. Nothing to do with `.ticker-bar` in `shell.css` -
   this one is the arrow beside a figure. */
.ticker { font-size: 12.5px; font-weight: 800; }
.ticker.up { color: var(--ok); } .ticker.down { color: var(--err); }
.sparkline { width: 100%; height: 28px; display: block; margin: 4px 0; }
.sparkline.up { color: var(--ok); } .sparkline.down { color: var(--err); }

/* ── invest: a buy side and a sell side, per card ─────────────────────── */
.invest-card .action-head { align-items: center; }
.icon-btn { margin-left: auto; padding: 5px 9px; }
.invest-trade { gap: 10px; }
.invest-side { display: flex; flex-direction: column; gap: 6px; }
.invest-side + .invest-side { padding-top: 8px; border-top: 1px solid var(--border); }
.invest-side button { width: 100%; }
/* Units on one side, orbs on the other - typing into either fills in the
   other through the current price, so "how many" and "how much" are always
   the same answer, asked whichever way is easier to think in. */
.amount-pair { flex-wrap: nowrap; gap: 8px; align-items: center; }
.amount-field { display: flex; flex-direction: column; gap: 3px; flex: 1; min-width: 0; }
.amount-field input { width: 100%; text-align: center; }
.amount-field .fine { text-align: center; }
.amount-eq { color: var(--muted-2); font-size: 13px; flex: none; }
/* A taller chart for the detail modal - the card's sparkline stays small. */
.invest-chart .sparkline { height: 90px; }

/* ── buildings ───────────────────────────────────────────────────────── */
/* A building card carries more than any other card in Orbis - a level, a
   quality, a condition bar, prices and takings - so it gets a little more room
   between its rows than the tighter action cards do. */
.building-card { gap: 8px; }
.building-card .bar-row { margin: 0; }
/* Shut for business: still on the map, visibly not open. */
.building-card.closed { opacity: .62; border-style: dashed; }
.building-facts { grid-template-columns: repeat(5, 1fr); margin: 0; }
/* The owner's desk is a different kind of screen from the public half: denser,
   and full of things that change the world. */
.desk-rule { border: 0; border-top: 1px solid var(--border); margin: 16px 0 12px; }
/* A heading in a wall of controls has to be a *lid on a group*, not a slightly
   bolder line in the stack - the desk is a dozen unrelated powers in a column
   (rename, price, rent, upgrade, mend, sell, raze) and without grouping it
   reads as one long undifferentiated form. The rule above each one is what
   turns the column into sections. */
.desk-heading { margin: 16px 0 0; padding-top: 12px; border-top: 1.5px solid var(--border-soft);
  font-family: var(--font-display); font-size: 13.5px; font-weight: 600;
  letter-spacing: .01em; color: var(--text-hi); }
.desk-heading:first-child { margin-top: 0; padding-top: 0; border-top: 0; }
.price-row { align-items: center; gap: 8px; flex-wrap: wrap; }
.price-row .fine:first-child { min-width: 110px; }
.warn-text { color: var(--warn); }

/* ── the city's warehouse ────────────────────────────────────────────────
 * Goods, drawn as goods. This was a wrapping row of text chips - the only
 * place in Orbis that described a pile of items instead of showing them - so
 * "has this city got glass" was a reading task rather than a glance. Tiles on
 * an auto-fill grid, sized to the number, because the number is the question
 * every single visit to this panel is asking. */
.city-stock { display: grid; gap: 10px; }
.stock-grid { display: grid; gap: 8px;
  grid-template-columns: repeat(auto-fill, minmax(84px, 1fr)); }
.stock-tile { display: grid; justify-items: center; gap: 2px; padding: 9px 6px;
  border-radius: var(--r-md); background: var(--panel-2);
  border: 1.5px solid var(--border); min-width: 0; }
.stock-icon { font-size: 21px; line-height: 1; }
img.stock-icon { width: 24px; height: 24px; object-fit: contain; }
/* The figures are the thing being compared against a build's bill, so they get
   the counting face and the size that goes with being the answer. */
.stock-qty { font-family: var(--font-num); font-size: 15px; color: var(--text-hi); }
.stock-name { font-size: 10.5px; font-weight: 700; color: var(--muted);
  max-width: 100%; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.city-stock .primary { justify-self: start; }

/* ── narrower ───────────────────────────────────────────────────────── */
@media (max-width: 620px) {
  .building-facts { grid-template-columns: repeat(3, 1fr); }
  .price-row .fine:first-child { min-width: 0; flex: 1 0 100%; }
}
@media (max-width: 560px) {
  .city-stats { grid-template-columns: repeat(2, 1fr); }
}

/* ── the world map ──────────────────────────────────────────────────────
 *
 * One <svg> and, inside it, nine <path>s, a tenth for the rivers, and a pin per
 * city - see `ui::map`, which cuts the visible patches of the world into runs
 * so a million cells arrive as ten elements.
 *
 * `shape-rendering: crispEdges` is doing real work: the paths tile exactly and
 * antialiasing between two of them draws a pale seam along every border in the
 * world, which reads as a road nobody built. */
/* `aspect-ratio` rather than `height: auto`: a fixed frame that the world is
   panned around inside, instead of one that changes height as you zoom. A map
   that resizes the page under itself while being dragged is unusable.

   Landscape, and `ui::map`'s `ASPECT` is the same number: the `viewBox` is cut
   to this shape too, so the extra width is more world rather than bars down
   the sides. A page is wider than it is tall and a square map wastes both
   edges of it.

   `vh` is what makes it a *screen* rather than a section of a page. A frame as
   wide as a desktop column is taller than the window, so the whole world never
   fits in the eye at once and the thing being panned is half off the bottom -
   which is exactly the state a map must not be in. Bounded by the viewport it
   is always whole, and the caption and the card below it are always visible. */
.map-frame { position: relative; border: 2px solid var(--border);
  border-radius: var(--r-lg); background: var(--map-void); overflow: hidden;
  aspect-ratio: 1.4; width: min(100%, 87vh); margin-inline: auto; }
.map { display: block; width: 100%; height: 100%; cursor: grab;
  /* Every gesture on this element belongs to the map. Without this the browser
     takes the drag for a scroll and the pinch for a page zoom, and the pointer
     events stop arriving halfway through. */
  touch-action: none; user-select: none; }
.map:active { cursor: grabbing; }
.map .g { shape-rendering: crispEdges; }
.g-ocean { fill: var(--map-ocean); }
.g-shallows { fill: var(--map-shallows); }
.g-shore { fill: var(--map-shore); }
.g-plains { fill: var(--map-plains); }
.g-forest { fill: var(--map-forest); }
.g-desert { fill: var(--map-desert); }
.g-tundra { fill: var(--map-tundra); }
.g-hills { fill: var(--map-hills); }
.g-mountains { fill: var(--map-mountains); }
.g-river { fill: var(--map-river); }

/* Territory. A wash rather than a fill: the ground under a city's fields is
   still the ground, and a solid colour over it would hide the thing the map is
   for. Yours is the gold the home pin already uses, so the two agree without a
   legend. `claimable` is a dashed outline over ground nobody holds - an offer,
   drawn only for the mayor who could take it. */
.map .held { fill: var(--text-hi); opacity: .13; shape-rendering: crispEdges; }
.map .held.home { fill: var(--gold); opacity: .3; }
.map .claimable { fill: none; stroke: var(--gold); stroke-width: 1.6px;
  stroke-dasharray: 4 3; vector-effect: non-scaling-stroke; opacity: .8;
  pointer-events: none; }

/* A road a caravan actually runs. Traced by `ui::map::roads` out of the same
   function and the same budget the server priced the route with, so this line is
   the deal rather than a picture of it - which is why it is worth drawing at
   all: a road bending around a range or following a river is the reason one
   neighbour is cheap to supply and another is not.

   `non-scaling-stroke` for the same reason the pins use it: a road two cells
   wide at world zoom would be a stripe across a continent, and a road a
   thousandth of a cell wide zoomed in would be nothing. Dashed while it is still
   only an offer, because a road nobody has agreed to is not a road yet. */
.map .road { fill: none; stroke: var(--gold); stroke-width: 2.5px;
  stroke-linejoin: round; stroke-linecap: round;
  vector-effect: non-scaling-stroke; opacity: .85; pointer-events: none; }
.map .road.offered { stroke-dasharray: 5 4; opacity: .55; }

/* A pin is a target on a phone before it is a dot: the ring is what makes a
   small circle tappable without making the world it sits on hard to read.
   Its radius is set in `ui::map` as a fraction of the zoom so that it keeps
   its size on screen; the stroke does the same trick declaratively, because a
   stroke that scaled with the world would swallow the pin at full zoom. */
.map .pin { fill: var(--panel); stroke: var(--text-hi); stroke-width: 1.4px;
  vector-effect: non-scaling-stroke; cursor: pointer;
  /* Grown on hover by transform rather than by `r`, because `r` is the thing
     the zoom is already writing and two authors of one number is a bug. */
  transform-box: fill-box; transform-origin: center;
  transition: transform .12s ease; }
.map .pin:hover { transform: scale(1.3); }
.map .pin.home { fill: var(--gold); stroke: var(--bg); stroke-width: 1.8px; }
.map .pin.picked { fill: var(--accent); stroke: var(--text-hi); stroke-width: 2px; }
/* Names appear only once there is room between two cities to write in - see
   `NAMED` in `ui::map`. The halo is what keeps a name legible over forest. */
.map .pin-name { fill: var(--text-hi); text-anchor: middle; font-weight: 700;
  paint-order: stroke; stroke: var(--bg); stroke-width: 3px;
  vector-effect: non-scaling-stroke; pointer-events: none; }

/* The zoom controls sit *on* the map, bottom right, because that is where a
   hand already is after dragging it. They are the keyboard's and the
   trackpad-less mouse's way in - the gestures cannot be the only way. */
.map-zoom { position: absolute; right: 8px; bottom: 8px; display: flex;
  flex-direction: column; gap: 5px; }
.map-zoom .icon-btn { margin: 0; width: 32px; height: 32px; padding: 0;
  font-size: 15px; line-height: 1; background: var(--panel);
  border: 1.5px solid var(--border); opacity: .92; }
.map-zoom .icon-btn:hover { opacity: 1; }
.map-scale { margin: 6px 0 10px; }

@media (prefers-reduced-motion: reduce) {
  .map .pin { transition: none; }
}

/* ── the field ─────────────────────────────────────────────────────────
   A battle card holds two sides, and each side is a stack of fighters with
   their bars. The card is rebuilt every push, so nothing in here animates on
   its own state - the bars slide because Bar's width does. */
.war-card .war-field { display: grid; grid-template-columns: 1fr 1fr; gap: 10px; }
@media (max-width: 640px) { .war-card .war-field { grid-template-columns: 1fr; } }
.war-side { display: flex; flex-direction: column; gap: 8px; min-width: 0; }
.fighter-row { border: 1px solid var(--border); border-radius: 8px; padding: 6px 8px;
  display: flex; flex-direction: column; gap: 4px; }
.fighter-row.down { opacity: .55; }
/* The question. Loud on purpose: it is the sharpest thing a player will ever
   be asked, and it must never look like part of the scenery. */
.war-edge { border: 2px solid var(--err); border-radius: 10px; padding: 10px;
  background: color-mix(in srgb, var(--err) 12%, var(--panel)); }
.war-log { border-top: 1px dashed var(--border); padding-top: 6px;
  display: flex; flex-direction: column; gap: 2px; max-height: 9em; overflow-y: auto; }
.fighter-row .chip.edge { color: var(--err); border-color: var(--err); }
.fighter-row .chip.spending { color: var(--err); }
.fighter-row .chip.fallen, .fighter-row .chip.beaten { color: var(--muted); }

/* ── the arena ─────────────────────────────────────────────────────────
   The pitch draws motion nobody eases in CSS: positions arrive already
   interpolated (a buffer sampled once per browser paint - see
   client/src/arena.rs), so transitions here would only smear them. What CSS
   owns is everything that is not a position: the grass, the markings, the
   announcements, the flight of the ball. */
.arena-host { display: flex; flex-direction: column; gap: 10px; }
.arena-purse-row { align-items: center; flex-wrap: wrap; }
/* The card is the field it describes: two benches facing each other, the
   join button on the bench it fills. */
.arena-card { display: flex; flex-direction: column; gap: 10px; }
.arena-head { align-items: center; gap: 8px; }
.arena-head .arena-ball { font-size: 19px; }
.arena-head b { font-size: 15px; }
.arena-final { font-family: var(--font-num); font-weight: 700; }
.arena-field-row { display: grid; grid-template-columns: 1fr auto 1fr; gap: 10px;
  align-items: stretch; }
.arena-vs { align-self: center; font-size: 12px; }
.arena-team { display: flex; flex-direction: column; gap: 5px; padding: 8px 10px;
  border: 1.5px solid var(--border); border-radius: var(--r-md);
  background: var(--panel-2); min-width: 0; }
.arena-team.side-a { border-left: 3px solid var(--accent); }
.arena-team.side-b { border-right: 3px solid var(--err); }
.arena-name-row { display: flex; align-items: center; gap: 7px; min-width: 0; }
.arena-team .arena-name { font-weight: 600; color: var(--text-hi);
  overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.arena-team button { align-self: flex-start; margin-top: 2px; }
.arena-foot { align-items: center; flex-wrap: wrap; }
.spacer { flex: 1; }
/* The screen never scrolls: the stage flexes, the pitch fits it (below),
   and everything transient is an overlay on the pitch itself. */
.match-screen { position: fixed; inset: 0; z-index: 60; background: var(--bg);
  display: flex; flex-direction: column; gap: 8px; padding: 10px;
  overflow: hidden; }
.match-top { align-items: center; flex-wrap: wrap; row-gap: 4px; }
.match-score { font-family: var(--font-num); font-size: 22px; font-weight: 700;
  color: var(--text-hi); }
.pitch-stage { flex: 1; min-height: 0; display: flex; align-items: center;
  justify-content: center; }
/* Sized against both walls at once: full width until the height under the
   scoreboard runs out, then the height rules. The whole game is always on
   screen - a pitch you have to scroll is not a pitch. */
.pitch { position: relative; aspect-ratio: 100 / 60;
  width: min(100%, calc((100vh - 104px) * (100 / 60)));
  width: min(100%, calc((100dvh - 104px) * (100 / 60)));
  background:
    repeating-linear-gradient(90deg,
      rgba(255, 255, 255, .028) 0 12.5%, transparent 12.5% 25%),
    radial-gradient(ellipse at center,
      color-mix(in srgb, var(--ok) 19%, var(--panel)) 0%,
      color-mix(in srgb, var(--ok) 12%, var(--panel)) 100%);
  border: 2px solid var(--border); border-radius: var(--r-lg);
  overflow: hidden; touch-action: none;
  box-shadow: inset 0 0 48px color-mix(in srgb, #000 30%, transparent); }
.pitch-line { position: absolute; left: 50%; top: 0; bottom: 0; width: 2px;
  background: color-mix(in srgb, var(--text-hi) 22%, transparent); }
.pitch-circle { position: absolute; left: 50%; top: 50%; width: 22%;
  aspect-ratio: 1; transform: translate(-50%, -50%); border-radius: 50%;
  border: 2px solid color-mix(in srgb, var(--text-hi) 22%, transparent); }
.pitch-box { position: absolute; top: 50%; transform: translateY(-50%);
  width: 15%; height: 56%;
  border: 2px solid color-mix(in srgb, var(--text-hi) 22%, transparent); }
.pitch-box-left { left: 0; border-left: 0; }
.pitch-box-right { right: 0; border-right: 0; }
/* The mouths, netted. */
.pitch .goal { position: absolute; top: 38.3%; height: 23.4%; width: 2.5%;
  border: 2px solid color-mix(in srgb, var(--text-hi) 55%, transparent);
  background:
    repeating-linear-gradient(0deg, rgba(255,255,255,.14) 0 1px, transparent 1px 5px),
    repeating-linear-gradient(90deg, rgba(255,255,255,.14) 0 1px, transparent 1px 5px);
  z-index: 1; }
.pitch .goal-left { left: 0; border-left: 0; }
.pitch .goal-right { right: 0; border-right: 0; }
/* Movers. Sizes are the physics: bodies are 4.4 units across on a 100-unit
   pitch, the ball 2 - what touches on screen is what touches in the game. */
.pitch .body, .pitch .ball, .pitch .ball-shadow { position: absolute;
  transform: translate(-50%, -50%); }
.pitch .body { width: 4.4%; aspect-ratio: 1; border-radius: 50%;
  display: grid; place-items: center; color: #fff; z-index: 2;
  border: 1.5px solid color-mix(in srgb, #000 35%, transparent);
  box-shadow: 0 2px 5px color-mix(in srgb, #000 35%, transparent); }
.pitch .body.side-a { background: var(--accent); }
.pitch .body.side-b { background: var(--err); }
.pitch .body.you { box-shadow: 0 0 0 2.5px var(--bg),
  0 0 0 5px color-mix(in srgb, var(--text-hi) 75%, transparent); }
/* The ball is at this body's feet. */
.pitch .body.holding { box-shadow: 0 0 0 2px #fff,
  0 0 10px 3px color-mix(in srgb, #fff 55%, transparent); }
.pitch .body.you.holding { box-shadow: 0 0 0 2.5px var(--bg),
  0 0 0 5px color-mix(in srgb, var(--text-hi) 75%, transparent),
  0 0 12px 4px color-mix(in srgb, #fff 60%, transparent); }
/* Which way this body will play the ball: a wedge riding the rim, rotated
   with the facing. The wrapper spans the body so rotation needs no math. */
.pitch .aim { position: absolute; inset: -20%; pointer-events: none;
  transition: transform 90ms linear; }
.pitch .aim-tip { position: absolute; right: -12%; top: 50%;
  transform: translateY(-50%); width: 0; height: 0;
  border-top: 4px solid transparent; border-bottom: 4px solid transparent;
  border-left: 7px solid color-mix(in srgb, var(--text-hi) 80%, transparent);
  filter: drop-shadow(0 1px 1px rgba(0, 0, 0, .5)); }
.pitch .body.you .aim-tip {
  border-left-color: var(--text-hi); }
/* The wind-up, over the head of whoever is winding - everybody sees the big
   one coming, which is the whole counterplay. */
.pitch .wind { position: absolute; left: -15%; right: -15%; top: -42%;
  height: 4px; border-radius: 2px;
  background: color-mix(in srgb, #000 45%, transparent); overflow: hidden; }
.pitch .wind-fill { display: block; height: 100%; border-radius: 2px;
  background: linear-gradient(90deg, var(--warn, #e8b93c), var(--err)); }
/* Your own sprint tank, under your feet, only while it is not full. */
.pitch .tank { position: absolute; left: -8%; right: -8%; bottom: -30%;
  height: 3px; border-radius: 2px;
  background: color-mix(in srgb, #000 45%, transparent); overflow: hidden; }
.pitch .tank-fill { display: block; height: 100%; border-radius: 2px;
  background: color-mix(in srgb, var(--ok) 80%, #fff); }
/* The face everybody already has, worn on the pitch: the avatar fills the
   body and takes the shirt color under it. */
.pitch .avatar { width: 100%; height: 100%; border: 0; box-shadow: none;
  background: transparent; color: #fff;
  font-size: clamp(8px, 1.4vw, 15px); }
.pitch .ball { width: 2%; aspect-ratio: 1; border-radius: 50%;
  background: radial-gradient(circle at 35% 30%, #fff 0%, #d8d8d8 75%);
  border: 1px solid #4a4a4a; z-index: 3; }
/* The ball's third dimension: the shadow stays on the grass, the ball
   lifts and grows (inline transform), and the gap between them is height. */
.pitch .ball-shadow { width: 2%; aspect-ratio: 1; border-radius: 50%;
  background: #000; filter: blur(2px); z-index: 1; }
/* Speed ghosts: where a fast mover just was, left behind for a blink. The
   smear is the sense of pace - it only appears past real speed, so a jog
   stays clean and a sprint, a lunge or a driven ball visibly tears. */
.pitch .ghost { position: absolute; transform: translate(-50%, -50%);
  width: 4.4%; aspect-ratio: 1; border-radius: 50%; pointer-events: none;
  opacity: .22; z-index: 1; }
.pitch .ghost.g2 { opacity: .1; scale: .85; }
.pitch .ghost.side-a { background: var(--accent); }
.pitch .ghost.side-b { background: var(--err); }
.pitch .ball-ghost { position: absolute; transform: translate(-50%, -50%);
  width: 2%; aspect-ratio: 1; border-radius: 50%; pointer-events: none;
  background: #fff; opacity: .28; z-index: 1; }
.pitch .ball-ghost.g2 { opacity: .12; scale: .8; }
/* Which way the wound shot will bend, beside the one bending it. */
.pitch .curve-hint { position: absolute; top: -70%; left: 78%;
  font-size: clamp(11px, 2vh, 18px); font-weight: 800; color: #fff;
  text-shadow: 0 1px 3px rgba(0, 0, 0, .7); pointer-events: none; }
/* The ticker lives on the grass, bottom corner, out of everybody's way. */
.pitch .match-shouts { position: absolute; left: 10px; bottom: 8px;
  display: flex; flex-direction: column; gap: 2px; pointer-events: none;
  color: #fff; text-shadow: 0 1px 3px rgba(0, 0, 0, .65); z-index: 4; }
.match-shouts .shout.goal { color: var(--ok); font-weight: 700; }
/* The big announcement: one fresh element per happening, whose animation
   plays once and fades itself out - juice with no timers to clean up. */
.pitch-roar { position: absolute; inset: 0; display: grid; place-items: center;
  pointer-events: none; z-index: 5; }
.roar-text { font-family: var(--font-display); font-weight: 800;
  font-size: clamp(22px, 6vw, 56px); color: #fff; text-align: center;
  text-shadow: 0 2px 14px rgba(0, 0, 0, .6);
  animation: roar-pop 1.8s cubic-bezier(.2, 1.4, .3, 1) forwards; }
.pitch-roar.goal::before { content: ""; position: absolute; inset: 0;
  background: radial-gradient(ellipse at center,
    color-mix(in srgb, var(--ok) 45%, transparent) 0%, transparent 70%);
  animation: roar-flash .9s ease-out forwards; }
.pitch-roar.goal .roar-text { animation: roar-pop 1.8s cubic-bezier(.2, 1.4, .3, 1) forwards,
  roar-shake .45s ease-out; }
@keyframes roar-pop {
  0% { transform: scale(.35); opacity: 0; }
  14% { transform: scale(1.12); opacity: 1; }
  24% { transform: scale(1); }
  78% { opacity: 1; }
  100% { transform: scale(1.05); opacity: 0; }
}
@keyframes roar-flash { from { opacity: .95; } to { opacity: 0; } }
@keyframes roar-shake {
  0%, 100% { translate: 0 0; }
  20% { translate: -6px 2px; } 40% { translate: 5px -3px; }
  60% { translate: -4px -2px; } 80% { translate: 3px 2px; }
}
.pitch .match-over { position: absolute; left: 50%; top: 50%;
  transform: translate(-50%, -50%); z-index: 6; text-align: center;
  font-size: 18px; display: flex; flex-direction: column; gap: 4px; }
/* Thumb hardware floats over the corners of the screen, the way every
   phone game holds it - the pitch keeps the whole viewport. */
.match-controls { position: absolute; left: 14px; right: 14px; bottom: 14px;
  display: flex; align-items: flex-end; justify-content: space-between;
  pointer-events: none; z-index: 70; }
.stick { width: 108px; height: 108px; border-radius: 50%; flex: none;
  border: 2px solid var(--border);
  background: color-mix(in srgb, var(--panel-2) 72%, transparent);
  display: flex; align-items: center; justify-content: center;
  touch-action: none; pointer-events: auto; }
.stick-dot { width: 34px; height: 34px; border-radius: 50%;
  background: var(--accent); opacity: .8; pointer-events: none; }
.kick-btn { min-width: 96px; min-height: 96px; border-radius: 50%;
  font-size: 17px; font-weight: 800; color: #fff; border: 0;
  background: color-mix(in srgb, var(--err) 82%, transparent);
  pointer-events: auto; }
@media (min-width: 900px) {
  /* A desktop plays on keys; the thumb hardware folds away. */
  .match-controls { display: none; }
}
@media (max-width: 699px) {
  /* The scoreboard is crowded enough; the pad explains itself. */
  .match-hint { display: none; }
}
@media (prefers-reduced-motion: reduce) {
  /* The announcement still announces, but only fades - no pop, no shake,
     no flash - and the aim snaps instead of sweeping. */
  .roar-text, .pitch-roar.goal .roar-text { animation: roar-quiet 1.6s ease-out forwards; }
  .pitch-roar.goal::before { animation: none; opacity: 0; }
  .pitch .aim { transition: none; }
  /* Motion smear is motion; whoever asked for less of it gets none. */
  .pitch .ghost, .pitch .ball-ghost { display: none !important; }
}
@keyframes roar-quiet { 0% { opacity: 0; } 15% { opacity: 1; }
  80% { opacity: 1; } 100% { opacity: 0; } }