Pre-bake backbone card art (instant, no shimmer) + stop warming face-down enemy hand

- 18 bundled JPEGs (6 backbone cards x 3 worlds); backbone_card is born with its
art_uri, so the base Attack/Block/Draw cards never shimmer and cost no live SDXL.
- Skip art generation for the enemy hand (rendered as card backs), freeing the art
lane so visible player cards illustrate faster.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

README.md

@@ -102,25 +102,43 @@ Install dependencies:
 python3 -m pip install -r requirements.txt
 ```
 
-Run the Gradio app without local model servers:
+Run the Gradio app without model servers:
 
 ```bash
 python3 app.py
 ```
 
-For the local AI path, start Tabras through:
+That path is fully local and playable: it uses the same deterministic engine and fallback card generation, with no model server required.
+
+For local AI card generation, install `llama-server` from llama.cpp, download the MiniCPM GGUF, and place it here:
+
+```text
+models/minicpm-v-4.6-gguf/MiniCPM-V-4.6-Q4_K_M.gguf
+```
+
+Then start Tabras through:
 
 ```bash
 python3 launch_ai.py
 ```
 
-`launch_ai.py` expects the MiniCPM GGUF at:
+`launch_ai.py` starts `llama-server` on `127.0.0.1:8090`, points Tabras at that OpenAI-compatible endpoint, uses local MLX for the Nemotron boss by default, and uses local Diffusers for SDXL-Turbo art.
 
-```text
-models/minicpm-v-4.6-gguf/MiniCPM-V-4.6-Q4_K_M.gguf
+You can also point any model role at a GPU machine you control. Set the endpoint/model environment variables before launching the app:
+
+```bash
+TABRAS_CARD_BACKEND=llamacpp
+TABRAS_CARD_ENDPOINT=http://YOUR_GPU_HOST:8090/v1/chat/completions
+TABRAS_CARD_MODEL=minicpm-v-4.6-q4
+TABRAS_AI_BOSS=1
+TABRAS_BOSS_BACKEND=openai
+TABRAS_BOSS_ENDPOINT=http://YOUR_GPU_HOST:8081/v1/chat/completions
+TABRAS_ART_BACKEND=modal
+TABRAS_ART_ENDPOINT=http://YOUR_GPU_HOST:8082/generate
+python3 app.py
 ```
 
-You can also configure backends with environment variables:
+For in-process local Transformers/Diffusers instead of OpenAI-compatible endpoints:
 
 ```bash
 TABRAS_CARD_BACKEND=transformers
@@ -133,6 +151,8 @@ TABRAS_ART_MODEL=stabilityai/sdxl-turbo
 python3 app_hf.py
 ```
 
+The submitted Space uses Modal GPU endpoints, but the same app can run with local CPU fallback, local model processes, in-process local models, or GPU endpoints that you configure.
+
 ## Project Structure
 
 | File | Purpose |

draft.py

@@ -1,3 +1,6 @@
+import base64
+import re
+from pathlib import Path
 from random import Random
 from typing import Callable
 
@@ -8,6 +11,24 @@ from primitives import School
 
 PackChooser = Callable[[tuple[Card, ...], tuple[Card, ...]], int]
 
+_CARD_ART = Path(__file__).parent / "assets" / "cards"
+_backbone_art_cache: dict[str, str] = {}
+
+
+# Return the pre-baked art data URI for a backbone card. The six backbone cards are
+# identical every run, so their art is generated once and bundled (no live SDXL call,
+# no shimmer).
+def prebaked_backbone_art(name: str, theme: str) -> str:
+    world = re.sub(r"[^a-z0-9]+", "", theme.lower())
+    card = re.sub(r"[^a-z0-9]+", "_", name.lower()).strip("_")
+    key = f"{world}__{card}"
+    if key not in _backbone_art_cache:
+        path = _CARD_ART / f"{key}.jpg"
+        _backbone_art_cache[key] = (
+            "data:image/jpeg;base64," + base64.b64encode(path.read_bytes()).decode("ascii") if path.exists() else ""
+        )
+    return _backbone_art_cache[key]
+
 BACKBONE_CARDS: tuple[tuple[str, int, Effect], ...] = (
     ("Attack (weak)", 1, Effect("deal", amount=2)),
     ("Attack (medium)", 3, Effect("deal", amount=4)),
@@ -23,9 +44,9 @@ def backbone_deck(school: School, theme: str) -> tuple[Card, ...]:
     return tuple(backbone_card(name, cost, effect, school, theme) for name, cost, effect in BACKBONE_CARDS)
 
 
-# Build one standardized backbone card.
+# Build one standardized backbone card, with pre-baked art so it never shimmers.
 def backbone_card(name: str, cost: int, effect: Effect, school: School, theme: str) -> Card:
-    return Card(name, cost, school, theme, (effect,), flavor=f"Standard {name.lower()}.")
+    return Card(name, cost, school, theme, (effect,), flavor=f"Standard {name.lower()}.", art_uri=prebaked_backbone_art(name, theme))
 
 
 # Build a full 15-card text deck with nine generated synergy cards.

tests/test_ui.py

@@ -547,6 +547,6 @@ def test_battle_warms_visible_card_art() -> None:
     forge.drain()
     state = refresh_art(state)
     duel = state.duel
+    # The player's hand is visible and fully illustrated; the enemy hand renders
+    # face-down (card backs), so its art is intentionally not warmed.
     assert all(card.art_uri for card in duel.player.hand)
-    assert all(card.art_uri for card in duel.enemy.hand)
-    assert any(not card.art_uri for card in duel.player.deck)

ui.py

@@ -385,8 +385,9 @@ def battle_opening_steps(
     )
     draw_cards(duel.player, OPENING_HAND_SIZE)
     draw_cards(duel.enemy, OPENING_HAND_SIZE)
+    # Only warm the player's hand: the enemy hand renders face-down (card backs),
+    # so generating its art just starves the art lane and the visible cards.
     warm_card_art(art_client, duel.player.hand)
-    warm_card_art(art_client, duel.enemy.hand)
     state = replace(
         state,
         enemy_deck=enemy_deck,
@@ -434,8 +435,8 @@ def collect_ready_battle(
 def warm_battle_art(art_client: ArtClient | None, state: RunState) -> None:
     if state.duel is None:
         return
+    # Player hand + the played-card showcase are visible; the enemy hand is not.
     warm_card_art(art_client, state.duel.player.hand)
-    warm_card_art(art_client, state.duel.enemy.hand)
     warm_card_art(art_client, tuple(card for _, card in state.showcase))